Merge branch 'microsoft:main' into cnm_dev

packages/playwright-core/browsers.json

@@ -39,7 +39,7 @@
     },
     {
       "name": "webkit",
-      "revision": "2132",
+      "revision": "2134",
       "installByDefault": true,
       "revisionOverrides": {
         "debian11-x64": "2105",

packages/playwright-core/bundles/utils/package-lock.json

@@ -167,6 +167,7 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz",
       "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==",
+      "license": "MIT",
       "engines": {
         "node": ">=0.1.90"
       }

packages/playwright-core/src/DEPS.list

@@ -8,10 +8,13 @@
 **
 
 [inprocess.ts]
+common/
 utils/
+server/utils
 
 [outofprocess.ts]
 client/
+common/
 protocol/
 utils/
 utils/isomorphic

packages/playwright-core/src/browserServerImpl.ts

@@ -21,7 +21,7 @@ import { helper } from './server/helper';
 import { serverSideCallMetadata } from './server/instrumentation';
 import { createPlaywright } from './server/playwright';
 import { createGuid } from './server/utils/crypto';
-import { rewriteErrorMessage } from './utils/stackTrace';
+import { rewriteErrorMessage } from './utils/isomorphic/stackTrace';
 import { ws } from './utilsBundle';
 
 import type { BrowserServer, BrowserServerLauncher } from './client/browserType';

packages/playwright-core/src/cli/driver.ts

@@ -19,7 +19,7 @@
 import * as fs from 'fs';
 
 import * as playwright from '../..';
-import { PipeTransport } from '../utils/pipeTransport';
+import { PipeTransport } from '../server/utils/pipeTransport';
 import { PlaywrightServer } from '../remote/playwrightServer';
 import { DispatcherConnection, PlaywrightDispatcher, RootDispatcher, createPlaywright } from '../server';
 import { gracefullyProcessExitDoNotHang } from '../server/utils/processLauncher';

packages/playwright-core/src/client/DEPS.list

@@ -1,5 +1,4 @@
 [*]
 ../common/
 ../protocol/
-../utils/**
+../utils/isomorphic
-../utilsBundle.ts

packages/playwright-core/src/client/android.ts

@@ -14,23 +14,23 @@
  * limitations under the License.
  */
 
-import { EventEmitter } from 'events';
+import { EventEmitter } from './eventEmitter';
-
 import { BrowserContext, prepareBrowserContextParams } from './browserContext';
 import { ChannelOwner } from './channelOwner';
 import { TargetClosedError, isTargetClosedError } from './errors';
 import { Events } from './events';
 import { Waiter } from './waiter';
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
 import { isRegExp, isString } from '../utils/isomorphic/rtti';
 import { monotonicTime } from '../utils/isomorphic/time';
 import { raceAgainstDeadline } from '../utils/isomorphic/timeoutRunner';
+import { connectOverWebSocket } from './webSocket';
 
 import type { Page } from './page';
 import type * as types from './types';
 import type * as api from '../../types/types';
 import type { AndroidServerLauncherImpl } from '../androidServerImpl';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 
 type Direction = 'down' | 'up' | 'left' | 'right';
@@ -69,9 +69,8 @@ export class Android extends ChannelOwner<channels.AndroidChannel> implements ap
     return await this._wrapApiCall(async () => {
       const deadline = options.timeout ? monotonicTime() + options.timeout : 0;
       const headers = { 'x-playwright-browser': 'android', ...options.headers };
-      const localUtils = this._connection.localUtils();
       const connectParams: channels.LocalUtilsConnectParams = { wsEndpoint, headers, slowMo: options.slowMo, timeout: options.timeout };
-      const connection = await localUtils.connect(connectParams);
+      const connection = await connectOverWebSocket(this._connection, connectParams);
 
       let device: AndroidDevice;
       connection.on('close', () => {

packages/playwright-core/src/client/artifact.ts

@@ -16,7 +16,7 @@
 
 import { ChannelOwner } from './channelOwner';
 import { Stream } from './stream';
-import { mkdirIfNeeded } from '../utils/fileUtils';
+import { mkdirIfNeeded } from './fileUtils';
 
 import type * as channels from '@protocol/channels';
 import type { Readable } from 'stream';

packages/playwright-core/src/client/browser.ts

@@ -20,7 +20,7 @@ import { CDPSession } from './cdpSession';
 import { ChannelOwner } from './channelOwner';
 import { isTargetClosedError } from './errors';
 import { Events } from './events';
-import { mkdirIfNeeded } from '../utils/fileUtils';
+import { mkdirIfNeeded } from './fileUtils';
 
 import type { BrowserType } from './browserType';
 import type { Page } from './page';

packages/playwright-core/src/client/browserContext.ts

@@ -34,19 +34,19 @@ import { Tracing } from './tracing';
 import { Waiter } from './waiter';
 import { WebError } from './webError';
 import { Worker } from './worker';
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
-import { mkdirIfNeeded } from '../utils/fileUtils';
+import { mkdirIfNeeded } from './fileUtils';
 import { headersObjectToArray } from '../utils/isomorphic/headers';
 import { urlMatchesEqual } from '../utils/isomorphic/urlMatch';
 import { isRegExp, isString } from '../utils/isomorphic/rtti';
-import { rewriteErrorMessage } from '../utils/stackTrace';
+import { rewriteErrorMessage } from '../utils/isomorphic/stackTrace';
 
 import type { BrowserType } from './browserType';
 import type { BrowserContextOptions, Headers, LaunchOptions, StorageState, WaitForEventOptions } from './types';
 import type * as structs from '../../types/structs';
 import type * as api from '../../types/types';
 import type { URLMatch } from '../utils/isomorphic/urlMatch';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 
 export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel> implements api.BrowserContext {
@@ -338,7 +338,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
   }
 
   async route(url: URLMatch, handler: network.RouteHandlerCallback, options: { times?: number } = {}): Promise<void> {
-    this._routes.unshift(new network.RouteHandler(this._options.baseURL, url, handler, options.times));
+    this._routes.unshift(new network.RouteHandler(this._platform, this._options.baseURL, url, handler, options.times));
     await this._updateInterceptionPatterns();
   }
 
@@ -361,11 +361,14 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
   }
 
   async routeFromHAR(har: string, options: { url?: string | RegExp, notFound?: 'abort' | 'fallback', update?: boolean, updateContent?: 'attach' | 'embed', updateMode?: 'minimal' | 'full' } = {}): Promise<void> {
+    const localUtils = this._connection.localUtils();
+    if (!localUtils)
+      throw new Error('Route from har is not supported in thin clients');
     if (options.update) {
       await this._recordIntoHAR(har, null, options);
       return;
     }
-    const harRouter = await HarRouter.create(this._connection.localUtils(), har, options.notFound || 'abort', { urlMatch: options.url });
+    const harRouter = await HarRouter.create(localUtils, har, options.notFound || 'abort', { urlMatch: options.url });
     this._harRouters.push(harRouter);
     await harRouter.addContextRoute(this);
   }
@@ -484,8 +487,11 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
         const isCompressed = harParams.content === 'attach' || harParams.path.endsWith('.zip');
         const needCompressed = harParams.path.endsWith('.zip');
         if (isCompressed && !needCompressed) {
+          const localUtils = this._connection.localUtils();
+          if (!localUtils)
+            throw new Error('Uncompressed har is not supported in thin clients');
           await artifact.saveAs(harParams.path + '.tmp');
-          await this._connection.localUtils().harUnzip({ zipFile: harParams.path + '.tmp', harFile: harParams.path });
+          await localUtils.harUnzip({ zipFile: harParams.path + '.tmp', harFile: harParams.path });
         } else {
           await artifact.saveAs(harParams.path);
         }

packages/playwright-core/src/client/browserType.ts

@@ -14,17 +14,16 @@
  * limitations under the License.
  */
 
-import path from 'path';
-
 import { Browser } from './browser';
 import { BrowserContext, prepareBrowserContextParams } from './browserContext';
 import { ChannelOwner } from './channelOwner';
 import { envObjectToArray } from './clientHelper';
 import { Events } from './events';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
 import { headersObjectToArray } from '../utils/isomorphic/headers';
 import { monotonicTime } from '../utils/isomorphic/time';
 import { raceAgainstDeadline } from '../utils/isomorphic/timeoutRunner';
+import { connectOverWebSocket } from './webSocket';
 
 import type { Playwright } from './playwright';
 import type { ConnectOptions, LaunchOptions, LaunchPersistentContextOptions, LaunchServerOptions, Logger } from './types';
@@ -100,7 +99,7 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
       ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
       env: options.env ? envObjectToArray(options.env) : undefined,
       channel: options.channel,
-      userDataDir: (path.isAbsolute(userDataDir) || !userDataDir) ? userDataDir : path.resolve(userDataDir),
+      userDataDir: (this._platform.path().isAbsolute(userDataDir) || !userDataDir) ? userDataDir : this._platform.path().resolve(userDataDir),
     };
     return await this._wrapApiCall(async () => {
       const result = await this._channel.launchPersistentContext(persistentParams);
@@ -124,7 +123,6 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
     return await this._wrapApiCall(async () => {
       const deadline = params.timeout ? monotonicTime() + params.timeout : 0;
       const headers = { 'x-playwright-browser': this.name(), ...params.headers };
-      const localUtils = this._connection.localUtils();
       const connectParams: channels.LocalUtilsConnectParams = {
         wsEndpoint: params.wsEndpoint,
         headers,
@@ -134,7 +132,7 @@ export class BrowserType extends ChannelOwner<channels.BrowserTypeChannel> imple
       };
       if ((params as any).__testHookRedirectPortForwarding)
         connectParams.socksProxyRedirectPortForTest = (params as any).__testHookRedirectPortForwarding;
-      const connection = await localUtils.connect(connectParams);
+      const connection = await connectOverWebSocket(this._connection, connectParams);
       let browser: Browser;
       connection.on('close', () => {
         // Emulate all pages, contexts and the browser closing upon disconnect.

packages/playwright-core/src/client/channelOwner.ts

@@ -16,16 +16,14 @@
 
 import { EventEmitter } from './eventEmitter';
 import { ValidationError, maybeFindValidator  } from '../protocol/validator';
-import { isUnderTest } from '../utils/debug';
+import { isUnderTest } from '../utils/isomorphic/debug';
-import { debugLogger } from '../utils/debugLogger';
+import { captureLibraryStackTrace, stringifyStackFrames } from '../utils/isomorphic/stackTrace';
-import { captureLibraryStackTrace, stringifyStackFrames } from '../utils/stackTrace';
-import { zones } from '../utils/zones';
 
 import type { ClientInstrumentation } from './clientInstrumentation';
 import type { Connection } from './connection';
 import type { Logger } from './types';
 import type { ValidatorContext } from '../protocol/validator';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 
 type Listener = (...args: any[]) => void;
@@ -158,7 +156,7 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
                   apiZone.params = params;
                   apiZone.reported = true;
                   this._instrumentation.onApiCallBegin(apiZone);
-                  logApiCall(this._logger, `=> ${apiZone.apiName} started`);
+                  logApiCall(this._platform, this._logger, `=> ${apiZone.apiName} started`);
                   return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone.apiName, apiZone.frames, apiZone.stepId);
                 }
                 // Since this api call is either internal, or has already been reported/traced once,
@@ -177,19 +175,19 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
 
   async _wrapApiCall<R>(func: (apiZone: ApiZone) => Promise<R>, isInternal?: boolean): Promise<R> {
     const logger = this._logger;
-    const existingApiZone = zones.zoneData<ApiZone>('apiZone');
+    const existingApiZone = this._platform.zones.current().data<ApiZone>();
     if (existingApiZone)
       return await func(existingApiZone);
 
     if (isInternal === undefined)
       isInternal = this._isInternalType;
-    const stackTrace = captureLibraryStackTrace();
+    const stackTrace = captureLibraryStackTrace(this._platform.pathSeparator);
     const apiZone: ApiZone = { apiName: stackTrace.apiName, frames: stackTrace.frames, isInternal, reported: false, userData: undefined, stepId: undefined };
 
     try {
-      const result = await zones.run('apiZone', apiZone, async () => await func(apiZone));
+      const result = await this._platform.zones.current().push(apiZone).run(async () => await func(apiZone));
       if (!isInternal) {
-        logApiCall(logger, `<= ${apiZone.apiName} succeeded`);
+        logApiCall(this._platform, logger, `<= ${apiZone.apiName} succeeded`);
         this._instrumentation.onApiCallEnd(apiZone);
       }
       return result;
@@ -204,7 +202,7 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
         e.stack = '';
       if (!isInternal) {
         apiZone.error = e;
-        logApiCall(logger, `<= ${apiZone.apiName} failed`);
+        logApiCall(this._platform, logger, `<= ${apiZone.apiName} failed`);
         this._instrumentation.onApiCallEnd(apiZone);
       }
       throw e;
@@ -227,10 +225,10 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
   }
 }
 
-function logApiCall(logger: Logger | undefined, message: string) {
+function logApiCall(platform: Platform, logger: Logger | undefined, message: string) {
   if (logger && logger.isEnabled('api', 'info'))
     logger.log('api', 'info', message, [], { color: 'cyan' });
-  debugLogger.log('api', message);
+  platform.log('api', message);
 }
 
 function tChannelImplToWire(names: '*' | string[], arg: any, path: string, context: ValidatorContext) {

packages/playwright-core/src/client/clientHelper.ts

@@ -18,7 +18,7 @@
 import { isString } from '../utils/isomorphic/rtti';
 
 import type * as types from './types';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 
 export function envObjectToArray(env: types.Env): { name: string, value: string }[] {
   const result: { name: string, value: string }[] = [];

packages/playwright-core/src/client/connection.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { EventEmitter } from 'events';
 
+import { EventEmitter } from './eventEmitter';
 import { Android, AndroidDevice, AndroidSocket } from './android';
 import { Artifact } from './artifact';
 import { Browser } from './browser';
@@ -42,14 +42,12 @@ import { Tracing } from './tracing';
 import { Worker } from './worker';
 import { WritableStream } from './writableStream';
 import { ValidationError, findValidator  } from '../protocol/validator';
-import { debugLogger } from '../utils/debugLogger';
+import { formatCallLog, rewriteErrorMessage } from '../utils/isomorphic/stackTrace';
-import { formatCallLog, rewriteErrorMessage } from '../utils/stackTrace';
-import { zones } from '../utils/zones';
 
 import type { ClientInstrumentation } from './clientInstrumentation';
 import type { HeadersArray } from './types';
 import type { ValidatorContext } from '../protocol/validator';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 
 class Root extends ChannelOwner<channels.RootChannel> {
@@ -110,8 +108,8 @@ export class Connection extends EventEmitter {
     return this._rawBuffers;
   }
 
-  localUtils(): LocalUtils {
+  localUtils(): LocalUtils | undefined {
-    return this._localUtils!;
+    return this._localUtils;
   }
 
   async initializePlaywright(): Promise<Playwright> {
@@ -139,9 +137,9 @@ export class Connection extends EventEmitter {
     const type = object._type;
     const id = ++this._lastId;
     const message = { id, guid, method, params };
-    if (debugLogger.isEnabled('channel')) {
+    if (this.platform.isLogEnabled('channel')) {
       // Do not include metadata in debug logs to avoid noise.
-      debugLogger.log('channel', 'SEND> ' + JSON.stringify(message));
+      this.platform.log('channel', 'SEND> ' + JSON.stringify(message));
     }
     const location = frames[0] ? { file: frames[0].file, line: frames[0].line, column: frames[0].column } : undefined;
     const metadata: channels.Metadata = { apiName, location, internal: !apiName, stepId };
@@ -149,7 +147,7 @@ export class Connection extends EventEmitter {
       this._localUtils?.addStackToTracingNoReply({ callData: { stack: frames, id } }).catch(() => {});
     // We need to exit zones before calling into the server, otherwise
     // when we receive events from the server, we would be in an API zone.
-    zones.empty().run(() => this.onmessage({ ...message, metadata }));
+    this.platform.zones.empty.run(() => this.onmessage({ ...message, metadata }));
     return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, apiName, type, method }));
   }
 
@@ -159,15 +157,15 @@ export class Connection extends EventEmitter {
 
     const { id, guid, method, params, result, error, log } = message as any;
     if (id) {
-      if (debugLogger.isEnabled('channel'))
+      if (this.platform.isLogEnabled('channel'))
-        debugLogger.log('channel', '<RECV ' + JSON.stringify(message));
+        this.platform.log('channel', '<RECV ' + JSON.stringify(message));
       const callback = this._callbacks.get(id);
       if (!callback)
         throw new Error(`Cannot find command to respond: ${id}`);
       this._callbacks.delete(id);
       if (error && !result) {
         const parsedError = parseError(error);
-        rewriteErrorMessage(parsedError, parsedError.message + formatCallLog(log));
+        rewriteErrorMessage(parsedError, parsedError.message + formatCallLog(this.platform, log));
         callback.reject(parsedError);
       } else {
         const validator = findValidator(callback.type, callback.method, 'Result');
@@ -176,8 +174,8 @@ export class Connection extends EventEmitter {
       return;
     }
 
-    if (debugLogger.isEnabled('channel'))
+    if (this.platform.isLogEnabled('channel'))
-      debugLogger.log('channel', '<EVENT ' + JSON.stringify(message));
+      this.platform.log('channel', '<EVENT ' + JSON.stringify(message));
     if (method === '__create__') {
       this._createRemoteObject(guid, params.type, params.guid, params.initializer);
       return;

packages/playwright-core/src/client/consoleMessage.ts

@@ -18,7 +18,7 @@ import { JSHandle } from './jsHandle';
 import { Page } from './page';
 
 import type * as api from '../../types/types';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 
 type ConsoleMessageLocation = channels.BrowserContextConsoleEvent['location'];

packages/playwright-core/src/client/electron.ts

@@ -22,7 +22,7 @@ import { TargetClosedError, isTargetClosedError } from './errors';
 import { Events } from './events';
 import { JSHandle, parseResult, serializeArgument } from './jsHandle';
 import { Waiter } from './waiter';
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
 
 import type { Page } from './page';
 import type { BrowserContextOptions, Env, Headers, WaitForEventOptions } from './types';

packages/playwright-core/src/client/elementHandle.ts

@@ -19,11 +19,11 @@ import { promisify } from 'util';
 
 import { Frame } from './frame';
 import { JSHandle, parseResult, serializeArgument } from './jsHandle';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
-import { fileUploadSizeLimit, mkdirIfNeeded } from '../utils/fileUtils';
+import { fileUploadSizeLimit, mkdirIfNeeded } from './fileUtils';
 import { isString } from '../utils/isomorphic/rtti';
-import { mime } from '../utilsBundle';
 import { WritableStream } from './writableStream';
+import { getMimeTypeForPath } from '../utils/isomorphic/mimeType';
 
 import type { BrowserContext } from './browserContext';
 import type { ChannelOwner } from './channelOwner';
@@ -31,7 +31,7 @@ import type { Locator } from './locator';
 import type { FilePayload, Rect, SelectOption, SelectOptionOptions } from './types';
 import type * as structs from '../../types/structs';
 import type * as api from '../../types/types';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 
 const pipelineAsync = promisify(pipeline);
@@ -327,7 +327,7 @@ export async function convertInputFiles(platform: Platform, files: string | File
 
 export function determineScreenshotType(options: { path?: string, type?: 'png' | 'jpeg' }): 'png' | 'jpeg' | undefined {
   if (options.path) {
-    const mimeType = mime.getType(options.path);
+    const mimeType = getMimeTypeForPath(options.path);
     if (mimeType === 'image/png')
       return 'png';
     else if (mimeType === 'image/jpeg')

packages/playwright-core/src/client/eventEmitter.ts

@@ -22,9 +22,7 @@
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { EventEmitter as OriginalEventEmitter } from 'events';
+import { isUnderTest } from '../utils/isomorphic/debug';
-
-import { isUnderTest } from '../utils/debug';
 
 import type { EventEmitter as EventEmitterType } from 'events';
 
@@ -32,6 +30,12 @@ type EventType = string | symbol;
 type Listener = (...args: any[]) => any;
 type EventMap = Record<EventType, Listener | Listener[]>;
 
+let defaultMaxListenersProvider = () => 10;
+
+export function setDefaultMaxListenersProvider(provider: () => number) {
+  defaultMaxListenersProvider = provider;
+}
+
 export class EventEmitter implements EventEmitterType {
 
   private _events: EventMap | undefined = undefined;
@@ -58,7 +62,7 @@ export class EventEmitter implements EventEmitterType {
   }
 
   getMaxListeners(): number {
-    return this._maxListeners === undefined ? OriginalEventEmitter.defaultMaxListeners : this._maxListeners;
+    return this._maxListeners === undefined ? defaultMaxListenersProvider() : this._maxListeners;
   }
 
   emit(type: EventType, ...args: any[]): boolean {

packages/playwright-core/src/client/fetch.ts

@@ -19,8 +19,8 @@ import { ChannelOwner } from './channelOwner';
 import { TargetClosedError, isTargetClosedError } from './errors';
 import { RawHeaders } from './network';
 import { Tracing } from './tracing';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
-import { mkdirIfNeeded } from '../utils/fileUtils';
+import { mkdirIfNeeded } from './fileUtils';
 import { headersObjectToArray } from '../utils/isomorphic/headers';
 import { isString } from '../utils/isomorphic/rtti';
 
@@ -29,7 +29,7 @@ import type { ClientCertificate, FilePayload, Headers, SetStorageState, StorageS
 import type { Serializable } from '../../types/structs';
 import type * as api from '../../types/types';
 import type { HeadersArray, NameValue } from '../common/types';
-import type { Platform } from '../utils/platform';
+import type { Platform } from '../common/platform';
 import type * as channels from '@protocol/channels';
 import type * as fs from 'fs';
 

packages/playwright-core/src/client/fileUtils.ts

@@ -14,17 +14,12 @@
  * limitations under the License.
  */
 
-import type { Platform } from './platform';
+import type { Platform } from '../common/platform';
 
+// Keep in sync with the server.
 export const fileUploadSizeLimit = 50 * 1024 * 1024;
 
 export async function mkdirIfNeeded(platform: Platform, filePath: string) {
   // This will harmlessly throw on windows if the dirname is the root directory.
   await platform.fs().promises.mkdir(platform.path().dirname(filePath), { recursive: true }).catch(() => {});
 }
-
-export async function removeFolders(platform: Platform, dirs: string[]): Promise<Error[]> {
-  return await Promise.all(dirs.map((dir: string) =>
-    platform.fs().promises.rm(dir, { recursive: true, force: true, maxRetries: 10 }).catch(e => e)
-  ));
-}

packages/playwright-core/src/client/frame.ts

@@ -15,8 +15,7 @@
  * limitations under the License.
  */
 
-import { EventEmitter } from 'events';
+import { EventEmitter } from './eventEmitter';
-
 import { ChannelOwner } from './channelOwner';
 import { addSourceUrlToScript } from './clientHelper';
 import { ElementHandle, convertInputFiles, convertSelectOptionValues } from './elementHandle';
@@ -26,7 +25,7 @@ import { FrameLocator, Locator, testIdAttributeName } from './locator';
 import * as network from './network';
 import { kLifecycleEvents } from './types';
 import { Waiter } from './waiter';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
 import { getByAltTextSelector, getByLabelSelector, getByPlaceholderSelector, getByRoleSelector, getByTestIdSelector, getByTextSelector, getByTitleSelector } from '../utils/isomorphic/locatorUtils';
 import { urlMatches } from '../utils/isomorphic/urlMatch';
 

packages/playwright-core/src/client/harRouter.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { debugLogger } from '../utils/debugLogger';
-
 import type { BrowserContext } from './browserContext';
 import type { LocalUtils } from './localUtils';
 import type { Route } from './network';
@@ -57,7 +55,7 @@ export class HarRouter {
     });
 
     if (response.action === 'redirect') {
-      debugLogger.log('api', `HAR: ${route.request().url()} redirected to ${response.redirectURL}`);
+      route._platform.log('api', `HAR: ${route.request().url()} redirected to ${response.redirectURL}`);
       await route._redirectNavigationRequest(response.redirectURL!);
       return;
     }
@@ -79,7 +77,7 @@ export class HarRouter {
     }
 
     if (response.action === 'error')
-      debugLogger.log('api', 'HAR: ' + response.message!);
+      route._platform.log('api', 'HAR: ' + response.message!);
     // Report the error, but fall through to the default handler.
 
     if (this._notFoundAction === 'abort') {

packages/playwright-core/src/client/localUtils.ts

@@ -15,12 +15,8 @@
  */
 
 import { ChannelOwner } from './channelOwner';
-import { Connection } from './connection';
-import * as localUtils from '../utils/localUtils';
 
-import type { HeadersArray, Size } from './types';
+import type { Size } from './types';
-import type { HarBackend } from '../utils/harBackend';
-import type { Platform } from '../utils/platform';
 import type * as channels from '@protocol/channels';
 
 type DeviceDescriptor = {
@@ -35,8 +31,6 @@ type Devices = { [name: string]: DeviceDescriptor };
 
 export class LocalUtils extends ChannelOwner<channels.LocalUtilsChannel> {
   readonly devices: Devices;
-  private _harBackends = new Map<string, HarBackend>();
-  private _stackSessions = new Map<string, localUtils.StackSession>();
 
   constructor(parent: ChannelOwner, type: string, guid: string, initializer: channels.LocalUtilsInitializer) {
     super(parent, type, guid, initializer);
@@ -47,132 +41,34 @@ export class LocalUtils extends ChannelOwner<channels.LocalUtilsChannel> {
   }
 
   async zip(params: channels.LocalUtilsZipParams): Promise<void> {
-    return await localUtils.zip(this._platform, this._stackSessions, params);
+    return await this._channel.zip(params);
   }
 
   async harOpen(params: channels.LocalUtilsHarOpenParams): Promise<channels.LocalUtilsHarOpenResult> {
-    return await localUtils.harOpen(this._platform, this._harBackends, params);
+    return await this._channel.harOpen(params);
   }
 
   async harLookup(params: channels.LocalUtilsHarLookupParams): Promise<channels.LocalUtilsHarLookupResult> {
-    return await localUtils.harLookup(this._harBackends, params);
+    return await this._channel.harLookup(params);
   }
 
   async harClose(params: channels.LocalUtilsHarCloseParams): Promise<void> {
-    return await localUtils.harClose(this._harBackends, params);
+    return await this._channel.harClose(params);
   }
 
   async harUnzip(params: channels.LocalUtilsHarUnzipParams): Promise<void> {
-    return await localUtils.harUnzip(params);
+    return await this._channel.harUnzip(params);
   }
 
   async tracingStarted(params: channels.LocalUtilsTracingStartedParams): Promise<channels.LocalUtilsTracingStartedResult> {
-    return await localUtils.tracingStarted(this._stackSessions, params);
+    return await this._channel.tracingStarted(params);
   }
 
   async traceDiscarded(params: channels.LocalUtilsTraceDiscardedParams): Promise<void> {
-    return await localUtils.traceDiscarded(this._platform, this._stackSessions, params);
+    return await this._channel.traceDiscarded(params);
   }
 
   async addStackToTracingNoReply(params: channels.LocalUtilsAddStackToTracingNoReplyParams): Promise<void> {
-    return await localUtils.addStackToTracingNoReply(this._stackSessions, params);
+    return await this._channel.addStackToTracingNoReply(params);
-  }
-
-  async connect(params: channels.LocalUtilsConnectParams): Promise<Connection> {
-    const transport = this._platform.ws ? new WebSocketTransport(this._platform) : new JsonPipeTransport(this);
-    const connectHeaders = await transport.connect(params);
-    const connection = new Connection(this, this._platform, this._instrumentation, connectHeaders);
-    connection.markAsRemote();
-    connection.on('close', () => transport.close());
-
-    let closeError: string | undefined;
-    const onTransportClosed = (reason?: string) => {
-      connection.close(reason || closeError);
-    };
-    transport.onClose(reason => onTransportClosed(reason));
-    connection.onmessage = message => transport.send(message).catch(() => onTransportClosed());
-    transport.onMessage(message => {
-      try {
-        connection!.dispatch(message);
-      } catch (e) {
-        closeError = String(e);
-        transport.close();
-      }
-    });
-    return connection;
-  }
-}
-interface Transport {
-  connect(params: channels.LocalUtilsConnectParams): Promise<HeadersArray>;
-  send(message: any): Promise<void>;
-  onMessage(callback: (message: object) => void): void;
-  onClose(callback: (reason?: string) => void): void;
-  close(): Promise<void>;
-}
-
-class JsonPipeTransport implements Transport {
-  private _pipe: channels.JsonPipeChannel | undefined;
-  private _owner: ChannelOwner<channels.LocalUtilsChannel>;
-
-  constructor(owner: ChannelOwner<channels.LocalUtilsChannel>) {
-    this._owner = owner;
-  }
-
-  async connect(params: channels.LocalUtilsConnectParams) {
-    const { pipe, headers: connectHeaders } = await this._owner._wrapApiCall(async () => {
-      return await this._owner._channel.connect(params);
-    }, /* isInternal */ true);
-    this._pipe = pipe;
-    return connectHeaders;
-  }
-
-  async send(message: object) {
-    this._owner._wrapApiCall(async () => {
-      await this._pipe!.send({ message });
-    }, /* isInternal */ true);
-  }
-
-  onMessage(callback: (message: object) => void) {
-    this._pipe!.on('message', ({ message }) => callback(message));
-  }
-
-  onClose(callback: (reason?: string) => void) {
-    this._pipe!.on('closed', ({ reason }) => callback(reason));
-  }
-
-  async close() {
-    await this._owner._wrapApiCall(async () => {
-      await this._pipe!.close().catch(() => {});
-    }, /* isInternal */ true);
-  }
-}
-
-class WebSocketTransport implements Transport {
-  private _platform: Platform;
-  private _ws: WebSocket | undefined;
-
-  constructor(platform: Platform) {
-    this._platform = platform;
-  }
-
-  async connect(params: channels.LocalUtilsConnectParams) {
-    this._ws = this._platform.ws!(params.wsEndpoint);
-    return [];
-  }
-
-  async send(message: object) {
-    this._ws!.send(JSON.stringify(message));
-  }
-
-  onMessage(callback: (message: object) => void) {
-    this._ws!.addEventListener('message', event => callback(JSON.parse(event.data)));
-  }
-
-  onClose(callback: (reason?: string) => void) {
-    this._ws!.addEventListener('close', () => callback());
-  }
-
-  async close() {
-    this._ws!.close();
   }
 }

packages/playwright-core/src/client/network.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { URLSearchParams } from 'url';
-
 import { ChannelOwner } from './channelOwner';
 import { isTargetClosedError } from './errors';
 import { Events } from './events';
@@ -23,15 +21,14 @@ import { APIResponse } from './fetch';
 import { Frame } from './frame';
 import { Waiter } from './waiter';
 import { Worker } from './worker';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
 import { headersObjectToArray } from '../utils/isomorphic/headers';
 import { urlMatches } from '../utils/isomorphic/urlMatch';
 import { LongStandingScope, ManualPromise } from '../utils/isomorphic/manualPromise';
 import { MultiMap } from '../utils/isomorphic/multimap';
 import { isRegExp, isString } from '../utils/isomorphic/rtti';
-import { rewriteErrorMessage } from '../utils/stackTrace';
+import { rewriteErrorMessage } from '../utils/isomorphic/stackTrace';
-import { zones } from '../utils/zones';
+import { getMimeTypeForPath } from '../utils/isomorphic/mimeType';
-import { mime } from '../utilsBundle';
 
 import type { BrowserContext } from './browserContext';
 import type { Page } from './page';
@@ -40,8 +37,8 @@ import type { Serializable } from '../../types/structs';
 import type * as api from '../../types/types';
 import type { HeadersArray } from '../common/types';
 import type { URLMatch } from '../utils/isomorphic/urlMatch';
-import type { Zone } from '../utils/zones';
 import type * as channels from '@protocol/channels';
+import type { Platform, Zone } from '../common/platform';
 
 export type NetworkCookie = {
   name: string,
@@ -414,7 +411,7 @@ export class Route extends ChannelOwner<channels.RouteChannel> implements api.Ro
     else if (options.json)
       headers['content-type'] = 'application/json';
     else if (options.path)
-      headers['content-type'] = mime.getType(options.path) || 'application/octet-stream';
+      headers['content-type'] = getMimeTypeForPath(options.path) || 'application/octet-stream';
     if (length && !('content-length' in headers))
       headers['content-length'] = String(length);
 
@@ -821,14 +818,14 @@ export class RouteHandler {
   readonly handler: RouteHandlerCallback;
   private _ignoreException: boolean = false;
   private _activeInvocations: Set<{ complete: Promise<void>, route: Route }> = new Set();
-  private _svedZone: Zone;
+  private _savedZone: Zone;
 
-  constructor(baseURL: string | undefined, url: URLMatch, handler: RouteHandlerCallback, times: number = Number.MAX_SAFE_INTEGER) {
+  constructor(platform: Platform, baseURL: string | undefined, url: URLMatch, handler: RouteHandlerCallback, times: number = Number.MAX_SAFE_INTEGER) {
     this._baseURL = baseURL;
     this._times = times;
     this.url = url;
     this.handler = handler;
-    this._svedZone = zones.current().without('apiZone');
+    this._savedZone = platform.zones.current().pop();
   }
 
   static prepareInterceptionPatterns(handlers: RouteHandler[]) {
@@ -852,7 +849,7 @@ export class RouteHandler {
   }
 
   public async handle(route: Route): Promise<boolean> {
-    return await this._svedZone.run(async () => this._handleImpl(route));
+    return await this._savedZone.run(async () => this._handleImpl(route));
   }
 
   private async _handleImpl(route: Route): Promise<boolean> {

packages/playwright-core/src/client/page.ts

@@ -33,9 +33,9 @@ import { Response, Route, RouteHandler, WebSocket,  WebSocketRoute, WebSocketRou
 import { Video } from './video';
 import { Waiter } from './waiter';
 import { Worker } from './worker';
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
-import { mkdirIfNeeded } from '../utils/fileUtils';
+import { mkdirIfNeeded } from './fileUtils';
 import { headersObjectToArray } from '../utils/isomorphic/headers';
 import { trimStringWithEllipsis  } from '../utils/isomorphic/stringUtils';
 import { urlMatches, urlMatchesEqual } from '../utils/isomorphic/urlMatch';
@@ -520,16 +520,19 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
   }
 
   async route(url: URLMatch, handler: RouteHandlerCallback, options: { times?: number } = {}): Promise<void> {
-    this._routes.unshift(new RouteHandler(this._browserContext._options.baseURL, url, handler, options.times));
+    this._routes.unshift(new RouteHandler(this._platform, this._browserContext._options.baseURL, url, handler, options.times));
     await this._updateInterceptionPatterns();
   }
 
   async routeFromHAR(har: string, options: { url?: string | RegExp, notFound?: 'abort' | 'fallback', update?: boolean, updateContent?: 'attach' | 'embed', updateMode?: 'minimal' | 'full'} = {}): Promise<void> {
+    const localUtils = this._connection.localUtils();
+    if (!localUtils)
+      throw new Error('Route from har is not supported in thin clients');
     if (options.update) {
       await this._browserContext._recordIntoHAR(har, this, options);
       return;
     }
-    const harRouter = await HarRouter.create(this._connection.localUtils(), har, options.notFound || 'abort', { urlMatch: options.url });
+    const harRouter = await HarRouter.create(localUtils, har, options.notFound || 'abort', { urlMatch: options.url });
     this._harRouters.push(harRouter);
     await harRouter.addPageRoute(this);
   }
@@ -796,7 +799,7 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
   }
 
   async pause(_options?: { __testHookKeepTestTimeout: boolean }) {
-    if (require('inspector').url())
+    if (this._platform.isDebuggerAttached())
       return;
     const defaultNavigationTimeout = this._browserContext._timeoutSettings.defaultNavigationTimeout();
     const defaultTimeout = this._browserContext._timeoutSettings.defaultTimeout();

packages/playwright-core/src/client/selectors.ts

@@ -17,19 +17,25 @@
 import { ChannelOwner } from './channelOwner';
 import { evaluationScript } from './clientHelper';
 import { setTestIdAttribute, testIdAttributeName } from './locator';
-import { nodePlatform } from '../utils/platform';
+import { emptyPlatform } from '../common/platform';
 
 import type { SelectorEngine } from './types';
 import type * as api from '../../types/types';
 import type * as channels from '@protocol/channels';
+import type { Platform } from '../common/platform';
 
+let platform = emptyPlatform;
+
+export function setPlatformForSelectors(p: Platform) {
+  platform = p;
+}
 
 export class Selectors implements api.Selectors {
   private _channels = new Set<SelectorsOwner>();
   private _registrations: channels.SelectorsRegisterParams[] = [];
 
   async register(name: string, script: string | (() => SelectorEngine) | { path?: string, content?: string }, options: { contentScript?: boolean } = {}): Promise<void> {
-    const source = await evaluationScript(nodePlatform, script, undefined, false);
+    const source = await evaluationScript(platform, script, undefined, false);
     const params = { ...options, name, source };
     for (const channel of this._channels)
       await channel._channel.register(params);

packages/playwright-core/src/client/tracing.ts

@@ -69,8 +69,8 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
       this._isTracing = true;
       this._connection.setIsTracing(true);
     }
-    const result = await this._connection.localUtils().tracingStarted({ tracesDir: this._tracesDir, traceName });
+    const result = await this._connection.localUtils()?.tracingStarted({ tracesDir: this._tracesDir, traceName });
-    this._stacksId = result.stacksId;
+    this._stacksId = result?.stacksId;
   }
 
   async stopChunk(options: { path?: string } = {}) {
@@ -89,15 +89,19 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
       // Not interested in artifacts.
       await this._channel.tracingStopChunk({ mode: 'discard' });
       if (this._stacksId)
-        await this._connection.localUtils().traceDiscarded({ stacksId: this._stacksId });
+        await this._connection.localUtils()!.traceDiscarded({ stacksId: this._stacksId });
       return;
     }
 
+    const localUtils = this._connection.localUtils();
+    if (!localUtils)
+      throw new Error('Cannot save trace in thin clients');
+
     const isLocal = !this._connection.isRemote();
 
     if (isLocal) {
       const result = await this._channel.tracingStopChunk({ mode: 'entries' });
-      await this._connection.localUtils().zip({ zipFile: filePath, entries: result.entries!, mode: 'write', stacksId: this._stacksId, includeSources: this._includeSources });
+      await localUtils.zip({ zipFile: filePath, entries: result.entries!, mode: 'write', stacksId: this._stacksId, includeSources: this._includeSources });
       return;
     }
 
@@ -106,7 +110,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
     // The artifact may be missing if the browser closed while stopping tracing.
     if (!result.artifact) {
       if (this._stacksId)
-        await this._connection.localUtils().traceDiscarded({ stacksId: this._stacksId });
+        await localUtils.traceDiscarded({ stacksId: this._stacksId });
       return;
     }
 
@@ -115,7 +119,7 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
     await artifact.saveAs(filePath);
     await artifact.delete();
 
-    await this._connection.localUtils().zip({ zipFile: filePath, entries: [], mode: 'append', stacksId: this._stacksId, includeSources: this._includeSources });
+    await localUtils.zip({ zipFile: filePath, entries: [], mode: 'append', stacksId: this._stacksId, includeSources: this._includeSources });
   }
 
   _resetStackCounter() {

packages/playwright-core/src/client/waiter.ts

@@ -15,13 +15,12 @@
  */
 
 import { TimeoutError } from './errors';
-import { rewriteErrorMessage } from '../utils/stackTrace';
+import { rewriteErrorMessage } from '../utils/isomorphic/stackTrace';
-import { zones } from '../utils/zones';
 
 import type { ChannelOwner } from './channelOwner';
-import type { Zone } from '../utils/zones';
 import type * as channels from '@protocol/channels';
 import type { EventEmitter } from 'events';
+import type { Zone } from '../common/platform';
 
 export class Waiter {
   private _dispose: (() => void)[];
@@ -36,7 +35,7 @@ export class Waiter {
   constructor(channelOwner: ChannelOwner<channels.EventTargetChannel>, event: string) {
     this._waitId = channelOwner._platform.createGuid();
     this._channelOwner = channelOwner;
-    this._savedZone = zones.current().without('apiZone');
+    this._savedZone = channelOwner._platform.zones.current().pop();
 
     this._channelOwner._channel.waitForEventInfo({ info: { waitId: this._waitId, phase: 'before', event } }).catch(() => {});
     this._dispose = [

packages/playwright-core/src/client/webSocket.ts

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ChannelOwner } from './channelOwner';
+import { Connection } from './connection';
+
+import type { HeadersArray } from './types';
+import type * as channels from '@protocol/channels';
+
+export async function connectOverWebSocket(parentConnection: Connection, params: channels.LocalUtilsConnectParams): Promise<Connection> {
+  const localUtils = parentConnection.localUtils();
+  const transport = localUtils ? new JsonPipeTransport(localUtils) : new WebSocketTransport();
+  const connectHeaders = await transport.connect(params);
+  const connection = new Connection(localUtils, parentConnection.platform, parentConnection._instrumentation, connectHeaders);
+  connection.markAsRemote();
+  connection.on('close', () => transport.close());
+
+  let closeError: string | undefined;
+  const onTransportClosed = (reason?: string) => {
+    connection.close(reason || closeError);
+  };
+  transport.onClose(reason => onTransportClosed(reason));
+  connection.onmessage = message => transport.send(message).catch(() => onTransportClosed());
+  transport.onMessage(message => {
+    try {
+      connection!.dispatch(message);
+    } catch (e) {
+      closeError = String(e);
+      transport.close();
+    }
+  });
+  return connection;
+}
+
+interface Transport {
+  connect(params: channels.LocalUtilsConnectParams): Promise<HeadersArray>;
+  send(message: any): Promise<void>;
+  onMessage(callback: (message: object) => void): void;
+  onClose(callback: (reason?: string) => void): void;
+  close(): Promise<void>;
+}
+
+class JsonPipeTransport implements Transport {
+  private _pipe: channels.JsonPipeChannel | undefined;
+  private _owner: ChannelOwner<channels.LocalUtilsChannel>;
+
+  constructor(owner: ChannelOwner<channels.LocalUtilsChannel>) {
+    this._owner = owner;
+  }
+
+  async connect(params: channels.LocalUtilsConnectParams) {
+    const { pipe, headers: connectHeaders } = await this._owner._wrapApiCall(async () => {
+      return await this._owner._channel.connect(params);
+    }, /* isInternal */ true);
+    this._pipe = pipe;
+    return connectHeaders;
+  }
+
+  async send(message: object) {
+    this._owner._wrapApiCall(async () => {
+      await this._pipe!.send({ message });
+    }, /* isInternal */ true);
+  }
+
+  onMessage(callback: (message: object) => void) {
+    this._pipe!.on('message', ({ message }) => callback(message));
+  }
+
+  onClose(callback: (reason?: string) => void) {
+    this._pipe!.on('closed', ({ reason }) => callback(reason));
+  }
+
+  async close() {
+    await this._owner._wrapApiCall(async () => {
+      await this._pipe!.close().catch(() => {});
+    }, /* isInternal */ true);
+  }
+}
+
+class WebSocketTransport implements Transport {
+  private _ws: WebSocket | undefined;
+
+  async connect(params: channels.LocalUtilsConnectParams) {
+    this._ws = new window.WebSocket(params.wsEndpoint);
+    return [];
+  }
+
+  async send(message: object) {
+    this._ws!.send(JSON.stringify(message));
+  }
+
+  onMessage(callback: (message: object) => void) {
+    this._ws!.addEventListener('message', event => callback(JSON.parse(event.data)));
+  }
+
+  onClose(callback: (reason?: string) => void) {
+    this._ws!.addEventListener('close', () => callback());
+  }
+
+  async close() {
+    this._ws!.close();
+  }
+}

packages/playwright-core/src/common/DEPS.list

@@ -1,4 +1,2 @@
 [*]
-../utils/
+../utils/isomorphic/
-../utilsBundle.ts
-../zipBundle.ts

packages/playwright-core/src/common/platform.ts

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { webColors, noColors } from '../utils/isomorphic/colors';
+
+import type * as fs from 'fs';
+import type * as path from 'path';
+import type { Colors } from '../utils/isomorphic/colors';
+
+export type Zone = {
+  push(data: unknown): Zone;
+  pop(): Zone;
+  run<R>(func: () => R): R;
+  data<T>(): T | undefined;
+};
+
+const noopZone: Zone = {
+  push: () => noopZone,
+  pop: () => noopZone,
+  run: func => func(),
+  data: () => undefined,
+};
+
+export type Platform = {
+  name: 'node' | 'web' | 'empty';
+
+  calculateSha1(text: string): Promise<string>;
+  colors: Colors;
+  createGuid: () => string;
+  fs: () => typeof fs;
+  inspectCustom: symbol | undefined;
+  isDebuggerAttached(): boolean;
+  isLogEnabled(name: 'api' | 'channel'): boolean;
+  log(name: 'api' | 'channel', message: string | Error | object): void;
+  path: () => typeof path;
+  pathSeparator: string;
+  zones: { empty: Zone, current: () => Zone; };
+};
+
+export const webPlatform: Platform = {
+  name: 'web',
+
+  calculateSha1: async (text: string) => {
+    const bytes = new TextEncoder().encode(text);
+    const hashBuffer = await window.crypto.subtle.digest('SHA-1', bytes);
+    return Array.from(new Uint8Array(hashBuffer), b => b.toString(16).padStart(2, '0')).join('');
+  },
+
+  colors: webColors,
+
+  createGuid: () => {
+    return Array.from(window.crypto.getRandomValues(new Uint8Array(16)), b => b.toString(16).padStart(2, '0')).join('');
+  },
+
+  fs: () => {
+    throw new Error('File system is not available');
+  },
+
+  inspectCustom: undefined,
+
+  isDebuggerAttached: () => false,
+
+  isLogEnabled(name: 'api' | 'channel') {
+    return false;
+  },
+
+  log(name: 'api' | 'channel', message: string | Error | object) {},
+
+  path: () => {
+    throw new Error('Path module is not available');
+  },
+
+  pathSeparator: '/',
+
+  zones: { empty: noopZone, current: () => noopZone },
+};
+
+export const emptyPlatform: Platform = {
+  name: 'empty',
+
+  calculateSha1: async () => {
+    throw new Error('Not implemented');
+  },
+
+  colors: noColors,
+
+  createGuid: () => {
+    throw new Error('Not implemented');
+  },
+
+  fs: () => {
+    throw new Error('Not implemented');
+  },
+
+  inspectCustom: undefined,
+
+  isDebuggerAttached: () => false,
+
+  isLogEnabled(name: 'api' | 'channel') {
+    return false;
+  },
+
+  log(name: 'api' | 'channel', message: string | Error | object) { },
+
+  path: () => {
+    throw new Error('Function not implemented.');
+  },
+
+  pathSeparator: '/',
+
+  zones: { empty: noopZone, current: () => noopZone },
+};

packages/playwright-core/src/common/progress.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface Progress {
-  log(message: string): void;
-  timeUntilDeadline(): number;
-  isRunning(): boolean;
-  cleanupWhenAborted(cleanup: () => any): void;
-  throwIfAborted(): void;
-}

packages/playwright-core/src/inProcessFactory.ts

@@ -14,17 +14,32 @@
  * limitations under the License.
  */
 
+import * as path from 'path';
+import { EventEmitter } from 'events';
+
 import { AndroidServerLauncherImpl } from './androidServerImpl';
 import { BrowserServerLauncherImpl } from './browserServerImpl';
 import { Connection } from './client/connection';
 import { DispatcherConnection, PlaywrightDispatcher, RootDispatcher, createPlaywright } from './server';
+import { setLibraryStackPrefix } from './utils/isomorphic/stackTrace';
+import { setDebugMode } from './utils/isomorphic/debug';
+import { getFromENV } from './server/utils/env';
+import { nodePlatform } from './server/utils/nodePlatform';
+import { setPlatformForSelectors } from './client/selectors';
+import { setDefaultMaxListenersProvider } from './client/eventEmitter';
 
 import type { Playwright as PlaywrightAPI } from './client/playwright';
 import type { Language } from './utils';
-import type { Platform } from './utils/platform';
+import type { Platform } from './common/platform';
+
 
 export function createInProcessPlaywright(platform: Platform): PlaywrightAPI {
   const playwright = createPlaywright({ sdkLanguage: (process.env.PW_LANG_NAME as Language | undefined) || 'javascript' });
+  setDebugMode(getFromENV('PWDEBUG') || '');
+  setPlatformForSelectors(nodePlatform);
+  setDefaultMaxListenersProvider(() => EventEmitter.defaultMaxListeners);
+
+  setLibraryStackPrefix(path.join(__dirname, '..'));
 
   const clientConnection = new Connection(undefined, platform, undefined, []);
   clientConnection.useRawBuffers();

packages/playwright-core/src/inprocess.ts

@@ -15,6 +15,6 @@
  */
 
 import { createInProcessPlaywright } from './inProcessFactory';
-import { nodePlatform } from './utils/platform';
+import { nodePlatform } from './server/utils/nodePlatform';
 
 module.exports = createInProcessPlaywright(nodePlatform);

packages/playwright-core/src/outofprocess.ts

@@ -18,9 +18,9 @@ import * as childProcess from 'child_process';
 import * as path from 'path';
 
 import { Connection } from './client/connection';
-import { PipeTransport } from './utils/pipeTransport';
+import { PipeTransport } from './server/utils/pipeTransport';
 import { ManualPromise } from './utils/isomorphic/manualPromise';
-import { nodePlatform } from './utils/platform';
+import { nodePlatform } from './server/utils/nodePlatform';
 
 import type { Playwright } from './client/playwright';
 

packages/playwright-core/src/protocol/DEPS.list

@@ -1,4 +1,3 @@
 [*]
 ../common/
-../utils/
+../utils/isomorphic
-

packages/playwright-core/src/protocol/validatorPrimitives.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { isUnderTest } from '../utils';
+import { isUnderTest } from '../utils/isomorphic/debug';
 
 export class ValidationError extends Error {}
 export type Validator = (arg: any, path: string, context: ValidatorContext) => any;

packages/playwright-core/src/remote/playwrightConnection.ts

@@ -23,7 +23,7 @@ import { serverSideCallMetadata } from '../server/instrumentation';
 import { assert, isUnderTest } from '../utils';
 import { startProfiling, stopProfiling } from '../server/utils/profiler';
 import { monotonicTime } from '../utils';
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from '../server/utils/debugLogger';
 
 import type { DispatcherScope, Playwright } from '../server';
 import type { LaunchOptions } from '../server/types';

packages/playwright-core/src/remote/playwrightServer.ts

@@ -16,11 +16,11 @@
 
 import { PlaywrightConnection } from './playwrightConnection';
 import { createPlaywright } from '../server/playwright';
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from '../server/utils/debugLogger';
 import { Semaphore } from '../utils/isomorphic/semaphore';
 import { WSServer } from '../server/utils/wsServer';
 import { wrapInASCIIBox } from '../server/utils/ascii';
-import { getPlaywrightVersion } from '../utils/userAgent';
+import { getPlaywrightVersion } from '../server/utils/userAgent';
 
 import type { ClientType } from './playwrightConnection';
 import type { SocksProxy } from '../server/utils/socksProxy';

packages/playwright-core/src/server/android/DEPS.list

@@ -3,6 +3,7 @@
 ../../common/
 ../../protocol/
 ../../utils/
+../../utils/isomorphic/
 ../../utilsBundle.ts
 ../chromium/
 ../utils

packages/playwright-core/src/server/android/android.ts

@@ -19,13 +19,13 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 
-import { TimeoutSettings } from '../../common/timeoutSettings';
+import { TimeoutSettings } from '../../utils/isomorphic/timeoutSettings';
-import { PipeTransport } from '../../utils/pipeTransport';
+import { PipeTransport } from '../utils/pipeTransport';
 import { createGuid } from '../utils/crypto';
-import { isUnderTest } from '../../utils/debug';
+import { isUnderTest } from '../../utils/isomorphic/debug';
-import { getPackageManagerExecCommand } from '../../utils/env';
+import { getPackageManagerExecCommand } from '../utils/env';
-import { makeWaitForNextTask } from '../../utils/task';
+import { makeWaitForNextTask } from '../utils/task';
-import { RecentLogsCollector } from '../../utils/debugLogger';
+import { RecentLogsCollector } from '../utils/debugLogger';
 import { debug } from '../../utilsBundle';
 import { wsReceiver, wsSender } from '../../utilsBundle';
 import { validateBrowserContextOptions } from '../browserContext';

packages/playwright-core/src/server/android/backendAdb.ts

@@ -17,7 +17,7 @@
 import { EventEmitter } from 'events';
 import * as net from 'net';
 
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 import { createGuid } from '../utils/crypto';
 import { debug } from '../../utilsBundle';
 

packages/playwright-core/src/server/bidi/bidiConnection.ts

@@ -16,11 +16,11 @@
 
 import { EventEmitter } from 'events';
 
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 import { helper } from '../helper';
 import { ProtocolError } from '../protocolError';
 
-import type { RecentLogsCollector } from '../../utils/debugLogger';
+import type { RecentLogsCollector } from '../utils/debugLogger';
 import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
 import type { ProtocolLogger } from '../types';
 import type * as bidiCommands from './third_party/bidiCommands';

packages/playwright-core/src/server/bidi/bidiExecutionContext.ts

@@ -16,6 +16,7 @@
 
 import { parseEvaluationResultValue } from '../isomorphic/utilityScriptSerializers';
 import * as js from '../javascript';
+import * as dom from '../dom';
 import { BidiDeserializer } from './third_party/bidiDeserializer';
 import * as bidi from './third_party/bidiProtocol';
 import { BidiSerializer } from './third_party/bidiSerializer';
@@ -137,7 +138,45 @@ export class BidiExecutionContext implements js.ExecutionContextDelegate {
     });
   }
 
-  async rawCallFunction(functionDeclaration: string, arg: bidi.Script.LocalValue): Promise<bidi.Script.RemoteValue> {
+
+  async nodeIdForElementHandle(handle: dom.ElementHandle): Promise<bidi.Script.SharedReference> {
+    const shared = await this._remoteValueForReference({ handle: handle._objectId });
+    // TODO: store sharedId in the handle.
+    if (!('sharedId' in shared))
+      throw new Error('Element is not a node');
+    return {
+      sharedId: shared.sharedId!,
+    };
+  }
+
+  async remoteObjectForNodeId(nodeId: bidi.Script.SharedReference): Promise<js.RemoteObject> {
+    const result = await this._remoteValueForReference(nodeId);
+    if ('handle' in result)
+      return { objectId: result.handle!, ...result };
+    throw new Error('Can\'t get remote object for nodeId');
+  }
+
+  async contentFrameIdForFrame(handle: dom.ElementHandle) {
+    const contentWindow = await this._rawCallFunction('e => e.contentWindow', { handle: handle._objectId });
+    if (contentWindow?.type === 'window')
+      return contentWindow.value.context;
+    return null;
+  }
+
+  async frameIdForWindowHandle(handle: js.JSHandle): Promise<string | null> {
+    if (!handle._objectId)
+      throw new Error('JSHandle is not a DOM node handle');
+    const contentWindow = await this._remoteValueForReference({ handle: handle._objectId });
+    if (contentWindow.type === 'window')
+      return contentWindow.value.context;
+    return null;
+  }
+
+  private async _remoteValueForReference(reference: bidi.Script.RemoteReference) {
+    return await this._rawCallFunction('e => e', reference);
+  }
+
+  private async _rawCallFunction(functionDeclaration: string, arg: bidi.Script.LocalValue): Promise<bidi.Script.RemoteValue> {
     const response = await this._session.send('script.callFunction', {
       functionDeclaration,
       target: this._target,

packages/playwright-core/src/server/bidi/bidiOverCdp.ts

@@ -17,7 +17,7 @@
 import * as bidiMapper from 'chromium-bidi/lib/cjs/bidiMapper/BidiMapper';
 import * as bidiCdpConnection from 'chromium-bidi/lib/cjs/cdp/CdpConnection';
 
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 
 import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
 import type { ChromiumBidi } from 'chromium-bidi/lib/cjs/protocol/protocol';

packages/playwright-core/src/server/bidi/bidiPage.ts

@@ -413,13 +413,10 @@ export class BidiPage implements PageDelegate {
 
   async getContentFrame(handle: dom.ElementHandle): Promise<frames.Frame | null> {
     const executionContext = toBidiExecutionContext(handle._context);
-    const contentWindow = await executionContext.rawCallFunction('e => e.contentWindow', { handle: handle._objectId });
+    const frameId = await executionContext.contentFrameIdForFrame(handle);
-    if (contentWindow.type === 'window') {
+    if (!frameId)
-      const frameId = contentWindow.value.context;
+      return null;
-      const result = this._page._frameManager.frame(frameId);
+    return this._page._frameManager.frame(frameId);
-      return result;
-    }
-    return null;
   }
 
   async getOwnerFrame(handle: dom.ElementHandle): Promise<string | null> {
@@ -430,15 +427,8 @@ export class BidiPage implements PageDelegate {
     });
     if (!windowHandle)
       return null;
-    if (!windowHandle._objectId)
+    const executionContext = toBidiExecutionContext(handle._context);
-      return null;
+    return executionContext.frameIdForWindowHandle(windowHandle);
-    const executionContext = toBidiExecutionContext(windowHandle._context as dom.FrameExecutionContext);
-    const contentWindow = await executionContext.rawCallFunction('e => e', { handle: windowHandle._objectId });
-    if (contentWindow.type === 'window') {
-      const frameId = contentWindow.value.context;
-      return frameId;
-    }
-    return null;
   }
 
   isElementHandle(remoteObject: bidi.Script.RemoteValue): boolean {
@@ -530,34 +520,26 @@ export class BidiPage implements PageDelegate {
   }
 
   async setInputFiles(handle: dom.ElementHandle<HTMLInputElement>, files: types.FilePayload[]): Promise<void> {
-    throw new Error('Setting FilePayloads is not supported in Bidi.');
+    await handle.evaluateInUtility(([injected, node, files]) =>
+      injected.setInputFiles(node, files), files);
   }
 
   async setInputFilePaths(handle: dom.ElementHandle<HTMLInputElement>, paths: string[]): Promise<void> {
     const fromContext = toBidiExecutionContext(handle._context);
-    const shared = await fromContext.rawCallFunction('x => x',  { handle: handle._objectId });
-    // TODO: store sharedId in the handle.
-    if (!('sharedId' in shared))
-      throw new Error('Element is not a node');
-    const sharedId = shared.sharedId!;
     await this._session.send('input.setFiles', {
       context: this._session.sessionId,
-      element: { sharedId },
+      element: await fromContext.nodeIdForElementHandle(handle),
       files: paths,
     });
   }
 
   async adoptElementHandle<T extends Node>(handle: dom.ElementHandle<T>, to: dom.FrameExecutionContext): Promise<dom.ElementHandle<T>> {
     const fromContext = toBidiExecutionContext(handle._context);
-    const shared = await fromContext.rawCallFunction('x => x',  { handle: handle._objectId });
+    const nodeId = await fromContext.nodeIdForElementHandle(handle);
-    // TODO: store sharedId in the handle.
-    if (!('sharedId' in shared))
-      throw new Error('Element is not a node');
-    const sharedId = shared.sharedId!;
     const executionContext = toBidiExecutionContext(to);
-    const result = await executionContext.rawCallFunction('x => x',  { sharedId });
+    const objectId = await executionContext.remoteObjectForNodeId(nodeId);
-    if ('handle' in result)
+    if (objectId)
-      return to.createHandle({ objectId: result.handle!, ...result }) as dom.ElementHandle<T>;
+      return to.createHandle(objectId) as dom.ElementHandle<T>;
     throw new Error('Failed to adopt element handle.');
   }
 

packages/playwright-core/src/server/browser.ts

@@ -24,7 +24,7 @@ import { ClientCertificatesProxy } from './socksClientCertificatesInterceptor';
 import type { CallMetadata } from './instrumentation';
 import type * as types from './types';
 import type { ProxySettings } from './types';
-import type { RecentLogsCollector } from '../utils/debugLogger';
+import type { RecentLogsCollector } from './utils/debugLogger';
 import type * as channels from '@protocol/channels';
 import type { ChildProcess } from 'child_process';
 

packages/playwright-core/src/server/browserContext.ts

@@ -18,9 +18,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
 import { createGuid } from './utils/crypto';
-import { debugMode } from '../utils/debug';
+import { debugMode } from '../utils/isomorphic/debug';
 import { Clock } from './clock';
 import { Debugger } from './debugger';
 import { BrowserContextAPIRequestContext } from './fetch';

packages/playwright-core/src/server/browserType.ts

@@ -19,7 +19,7 @@ import * as os from 'os';
 import * as path from 'path';
 
 import { normalizeProxySettings, validateBrowserContextOptions } from './browserContext';
-import { DEFAULT_TIMEOUT, TimeoutSettings } from '../common/timeoutSettings';
+import { DEFAULT_TIMEOUT, TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
 import { ManualPromise, assert, debugMode } from '../utils';
 import { existsAsync } from './utils/fileUtils';
 import { helper } from './helper';
@@ -31,7 +31,7 @@ import {  isProtocolError } from './protocolError';
 import { registry } from './registry';
 import { ClientCertificatesProxy } from './socksClientCertificatesInterceptor';
 import { WebSocketTransport } from './transport';
-import { RecentLogsCollector } from '../utils/debugLogger';
+import { RecentLogsCollector } from './utils/debugLogger';
 
 import type { Browser, BrowserOptions, BrowserProcess } from './browser';
 import type { BrowserContext } from './browserContext';

packages/playwright-core/src/server/chromium/chromium.ts

@@ -22,13 +22,13 @@ import * as path from 'path';
 import { chromiumSwitches } from './chromiumSwitches';
 import { CRBrowser } from './crBrowser';
 import { kBrowserCloseMessageId } from './crConnection';
-import { TimeoutSettings } from '../../common/timeoutSettings';
+import { TimeoutSettings } from '../../utils/isomorphic/timeoutSettings';
 import { debugMode, headersArrayToObject, headersObjectToArray, } from '../../utils';
 import { wrapInASCIIBox } from '../utils/ascii';
-import { RecentLogsCollector } from '../../utils/debugLogger';
+import { RecentLogsCollector } from '../utils/debugLogger';
 import { ManualPromise } from '../../utils/isomorphic/manualPromise';
 import { fetchData } from '../utils/network';
-import { getUserAgent } from '../../utils/userAgent';
+import { getUserAgent } from '../utils/userAgent';
 import { validateBrowserContextOptions } from '../browserContext';
 import { BrowserType, kNoXServerRunningError } from '../browserType';
 import { BrowserReadyState } from '../browserType';

packages/playwright-core/src/server/chromium/crBrowser.ts

@@ -17,7 +17,7 @@
 
 import * as path from 'path';
 
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 import { createGuid } from '../utils/crypto';
 import { Artifact } from '../artifact';
 import { Browser } from '../browser';

packages/playwright-core/src/server/chromium/crConnection.ts

@@ -18,14 +18,14 @@
 import { EventEmitter } from 'events';
 
 import {  assert, eventsHelper } from '../../utils';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 import { helper } from '../helper';
 import { ProtocolError } from '../protocolError';
 
 import type { RegisteredListener } from '../../utils';
 import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
 import type { Protocol } from './protocol';
-import type { RecentLogsCollector } from '../../utils/debugLogger';
+import type { RecentLogsCollector } from '../utils/debugLogger';
 import type { ProtocolLogger } from '../types';
 
 

packages/playwright-core/src/server/chromium/crExecutionContext.ts

@@ -16,7 +16,7 @@
  */
 
 import { getExceptionMessage, releaseObject } from './crProtocolHelper';
-import { rewriteErrorMessage } from '../../utils/stackTrace';
+import { rewriteErrorMessage } from '../../utils/isomorphic/stackTrace';
 import { parseEvaluationResultValue } from '../isomorphic/utilityScriptSerializers';
 import * as js from '../javascript';
 import { isSessionClosedError } from '../protocolError';

packages/playwright-core/src/server/chromium/crPage.ts

@@ -17,10 +17,10 @@
 
 import * as path from 'path';
 
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 import { createGuid } from '../utils/crypto';
 import { eventsHelper } from '../utils/eventsHelper';
-import { rewriteErrorMessage } from '../../utils/stackTrace';
+import { rewriteErrorMessage } from '../../utils/isomorphic/stackTrace';
 import * as dialog from '../dialog';
 import * as dom from '../dom';
 import * as frames from '../frames';

packages/playwright-core/src/server/chromium/crProtocolHelper.ts

@@ -17,7 +17,7 @@
 
 import * as fs from 'fs';
 
-import { splitErrorMessage } from '../../utils/stackTrace';
+import { splitErrorMessage } from '../../utils/isomorphic/stackTrace';
 import { mkdirIfNeeded } from '../utils/fileUtils';
 
 import type { CRSession } from './crConnection';

packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts

@@ -16,9 +16,8 @@
 
 import { Dispatcher } from './dispatcher';
 import { SdkObject } from '../../server/instrumentation';
-import * as localUtils from '../../utils/localUtils';
+import * as localUtils from '../localUtils';
-import { nodePlatform } from '../../utils/platform';
+import { getUserAgent } from '../utils/userAgent';
-import { getUserAgent } from '../../utils/userAgent';
 import { deviceDescriptors as descriptors }  from '../deviceDescriptors';
 import { JsonPipeDispatcher } from '../dispatchers/jsonPipeDispatcher';
 import { Progress, ProgressController } from '../progress';
@@ -26,7 +25,7 @@ import { SocksInterceptor } from '../socksInterceptor';
 import { WebSocketTransport } from '../transport';
 import { fetchData } from '../utils/network';
 
-import type { HarBackend } from '../../utils/harBackend';
+import type { HarBackend } from '../harBackend';
 import type { CallMetadata } from '../instrumentation';
 import type { Playwright } from '../playwright';
 import type { RootDispatcher } from './dispatcher';
@@ -50,11 +49,11 @@ export class LocalUtilsDispatcher extends Dispatcher<{ guid: string }, channels.
   }
 
   async zip(params: channels.LocalUtilsZipParams): Promise<void> {
-    return await localUtils.zip(nodePlatform, this._stackSessions, params);
+    return await localUtils.zip(this._stackSessions, params);
   }
 
   async harOpen(params: channels.LocalUtilsHarOpenParams, metadata: CallMetadata): Promise<channels.LocalUtilsHarOpenResult> {
-    return await localUtils.harOpen(nodePlatform, this._harBackends, params);
+    return await localUtils.harOpen(this._harBackends, params);
   }
 
   async harLookup(params: channels.LocalUtilsHarLookupParams, metadata: CallMetadata): Promise<channels.LocalUtilsHarLookupResult> {
@@ -74,7 +73,7 @@ export class LocalUtilsDispatcher extends Dispatcher<{ guid: string }, channels.
   }
 
   async traceDiscarded(params: channels.LocalUtilsTraceDiscardedParams, metadata?: CallMetadata | undefined): Promise<void> {
-    return await localUtils.traceDiscarded(nodePlatform, this._stackSessions, params);
+    return await localUtils.traceDiscarded(this._stackSessions, params);
   }
 
   async addStackToTracingNoReply(params: channels.LocalUtilsAddStackToTracingNoReplyParams, metadata?: CallMetadata | undefined): Promise<void> {

packages/playwright-core/src/server/electron/DEPS.list

@@ -2,5 +2,6 @@
 ../
 ../../common/
 ../../utils/
+../../utils/isomorphic/
 ../chromium/
 ../utils

packages/playwright-core/src/server/electron/electron.ts

@@ -19,10 +19,10 @@ import * as os from 'os';
 import * as path from 'path';
 import * as readline from 'readline';
 
-import { TimeoutSettings } from '../../common/timeoutSettings';
+import { TimeoutSettings } from '../../utils/isomorphic/timeoutSettings';
 import { ManualPromise } from '../../utils';
 import { wrapInASCIIBox } from '../utils/ascii';
-import { RecentLogsCollector } from '../../utils/debugLogger';
+import { RecentLogsCollector } from '../utils/debugLogger';
 import { eventsHelper } from '../utils/eventsHelper';
 import { validateBrowserContextOptions } from '../browserContext';
 import { CRBrowser } from '../chromium/crBrowser';

packages/playwright-core/src/server/fetch.ts

@@ -21,10 +21,10 @@ import { TLSSocket } from 'tls';
 import * as url from 'url';
 import * as zlib from 'zlib';
 
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
 import { assert, constructURLBasedOnBaseURL, eventsHelper, monotonicTime  } from '../utils';
 import { createGuid } from './utils/crypto';
-import { getUserAgent } from '../utils/userAgent';
+import { getUserAgent } from './utils/userAgent';
 import { HttpsProxyAgent, SocksProxyAgent } from '../utilsBundle';
 import { BrowserContext, verifyClientCertificates } from './browserContext';
 import { CookieStore, domainMatches, parseRawCookie } from './cookieStore';

packages/playwright-core/src/server/fileUploadUtils.ts

@@ -17,8 +17,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
-import { fileUploadSizeLimit } from '../utils/fileUtils';
 import { mime } from '../utilsBundle';
 
 import type { WritableStreamDispatcher } from './dispatchers/writableStreamDispatcher';
@@ -27,6 +26,9 @@ import type { Frame } from './frames';
 import type * as types from './types';
 import type * as channels from '@protocol/channels';
 
+// Keep in sync with the client.
+export const fileUploadSizeLimit = 50 * 1024 * 1024;
+
 async function filesExceedUploadLimit(files: string[]) {
   const sizes = await Promise.all(files.map(async file => (await fs.promises.stat(file)).size));
   return sizes.reduce((total, size) => total + size, 0) >= fileUploadSizeLimit;

packages/playwright-core/src/server/firefox/ffConnection.ts

@@ -17,13 +17,13 @@
 
 import { EventEmitter } from 'events';
 
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 import { helper } from '../helper';
 import { ProtocolError } from '../protocolError';
 
 import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
 import type { Protocol } from './protocol';
-import type { RecentLogsCollector } from '../../utils/debugLogger';
+import type { RecentLogsCollector } from '../utils/debugLogger';
 import type { ProtocolLogger } from '../types';
 
 

packages/playwright-core/src/server/firefox/ffExecutionContext.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { rewriteErrorMessage } from '../../utils/stackTrace';
+import { rewriteErrorMessage } from '../../utils/isomorphic/stackTrace';
 import { parseEvaluationResultValue } from '../isomorphic/utilityScriptSerializers';
 import * as js from '../javascript';
 import { isSessionClosedError } from '../protocolError';

packages/playwright-core/src/server/firefox/ffPage.ts

@@ -25,8 +25,8 @@ import { FFSession } from './ffConnection';
 import { FFExecutionContext } from './ffExecutionContext';
 import { RawKeyboardImpl, RawMouseImpl, RawTouchscreenImpl } from './ffInput';
 import { FFNetworkManager } from './ffNetworkManager';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
-import { splitErrorMessage } from '../../utils/stackTrace';
+import { splitErrorMessage } from '../../utils/isomorphic/stackTrace';
 import { BrowserContext } from '../browserContext';
 import { TargetClosedError } from '../errors';
 

packages/playwright-core/src/server/frames.ts

@@ -29,7 +29,7 @@ import { ProgressController } from './progress';
 import * as types from './types';
 import { LongStandingScope, asLocator, assert, compressCallLog, constructURLBasedOnBaseURL, makeWaitForNextTask, monotonicTime } from '../utils';
 import { isSessionClosedError } from './protocolError';
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from './utils/debugLogger';
 import { eventsHelper } from './utils/eventsHelper';
 import {  isInvalidSelectorError } from '../utils/isomorphic/selectorParser';
 import { ManualPromise } from '../utils/isomorphic/manualPromise';

packages/playwright-core/src/server/harBackend.ts

@@ -14,11 +14,14 @@
  * limitations under the License.
  */
 
-import { ZipFile } from './zipFile';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { createGuid } from './utils/crypto';
+import { ZipFile } from './utils/zipFile';
 
 import type { HeadersArray } from '../common/types';
 import type * as har from '@trace/har';
-import type { Platform } from './platform';
 
 const redirectStatus = [301, 302, 303, 307, 308];
 
@@ -27,11 +30,9 @@ export class HarBackend {
   private _harFile: har.HARFile;
   private _zipFile: ZipFile | null;
   private _baseDir: string | null;
-  private _platform: Platform;
 
-  constructor(platform: Platform, harFile: har.HARFile, baseDir: string | null, zipFile: ZipFile | null) {
+  constructor(harFile: har.HARFile, baseDir: string | null, zipFile: ZipFile | null) {
-    this._platform = platform;
+    this.id = createGuid();
-    this.id = platform.createGuid();
     this._harFile = harFile;
     this._baseDir = baseDir;
     this._zipFile = zipFile;
@@ -79,7 +80,7 @@ export class HarBackend {
       if (this._zipFile)
         buffer = await this._zipFile.read(file);
       else
-        buffer = await this._platform.fs().promises.readFile(this._platform.path().resolve(this._baseDir!, file));
+        buffer = await fs.promises.readFile(path.resolve(this._baseDir!, file));
     } else {
       buffer = Buffer.from(content.text || '', content.encoding === 'base64' ? 'base64' : 'utf-8');
     }

packages/playwright-core/src/server/helper.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from './utils/debugLogger';
 import { eventsHelper } from './utils/eventsHelper';
 
 import type { Progress } from './progress';

packages/playwright-core/src/server/localUtils.ts

@@ -18,15 +18,15 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 
-import { removeFolders } from './fileUtils';
+import { calculateSha1 } from './utils/crypto';
 import { HarBackend } from './harBackend';
-import { ManualPromise } from './isomorphic/manualPromise';
+import { ManualPromise } from '../utils/isomorphic/manualPromise';
-import { ZipFile } from './zipFile';
+import { ZipFile } from './utils/zipFile';
 import { yauzl, yazl } from '../zipBundle';
 import { serializeClientSideCallMetadata } from '../utils/isomorphic/traceUtils';
-import { assert } from '../utils/debug';
+import { assert } from '../utils/isomorphic/debug';
+import { removeFolders } from './utils/fileUtils';
 
-import type { Platform } from './platform';
 import type * as channels from '@protocol/channels';
 import type * as har from '@trace/har';
 import type EventEmitter from 'events';
@@ -39,7 +39,7 @@ export type StackSession = {
   callStacks: channels.ClientSideCallMetadata[];
 };
 
-export async function zip(platform: Platform, stackSessions: Map<string, StackSession>, params: channels.LocalUtilsZipParams): Promise<void> {
+export async function zip(stackSessions: Map<string, StackSession>, params: channels.LocalUtilsZipParams): Promise<void> {
   const promise = new ManualPromise<void>();
   const zipFile = new yazl.ZipFile();
   (zipFile as any as EventEmitter).on('error', error => promise.reject(error));
@@ -77,7 +77,7 @@ export async function zip(platform: Platform, stackSessions: Map<string, StackSe
         sourceFiles.add(file);
     }
     for (const sourceFile of sourceFiles)
-      addFile(sourceFile, 'resources/src@' + await platform.calculateSha1(sourceFile) + '.txt');
+      addFile(sourceFile, 'resources/src@' + await calculateSha1(sourceFile) + '.txt');
   }
 
   if (params.mode === 'write') {
@@ -89,7 +89,7 @@ export async function zip(platform: Platform, stackSessions: Map<string, StackSe
           .on('error', error => promise.reject(error));
     });
     await promise;
-    await deleteStackSession(platform, stackSessions, params.stacksId);
+    await deleteStackSession(stackSessions, params.stacksId);
     return;
   }
 
@@ -124,20 +124,20 @@ export async function zip(platform: Platform, stackSessions: Map<string, StackSe
     });
   });
   await promise;
-  await deleteStackSession(platform, stackSessions, params.stacksId);
+  await deleteStackSession(stackSessions, params.stacksId);
 }
 
-async function deleteStackSession(platform: Platform, stackSessions: Map<string, StackSession>, stacksId?: string) {
+async function deleteStackSession(stackSessions: Map<string, StackSession>, stacksId?: string) {
   const session = stacksId ? stackSessions.get(stacksId) : undefined;
   if (!session)
     return;
   await session.writer;
   if (session.tmpDir)
-    await removeFolders(platform, [session.tmpDir]);
+    await removeFolders([session.tmpDir]);
   stackSessions.delete(stacksId!);
 }
 
-export async function harOpen(platform: Platform, harBackends: Map<string, HarBackend>, params: channels.LocalUtilsHarOpenParams): Promise<channels.LocalUtilsHarOpenResult> {
+export async function harOpen(harBackends: Map<string, HarBackend>, params: channels.LocalUtilsHarOpenParams): Promise<channels.LocalUtilsHarOpenResult> {
   let harBackend: HarBackend;
   if (params.file.endsWith('.zip')) {
     const zipFile = new ZipFile(params.file);
@@ -147,10 +147,10 @@ export async function harOpen(platform: Platform, harBackends: Map<string, HarBa
       return { error: 'Specified archive does not have a .har file' };
     const har = await zipFile.read(harEntryName);
     const harFile = JSON.parse(har.toString()) as har.HARFile;
-    harBackend = new HarBackend(platform, harFile, null, zipFile);
+    harBackend = new HarBackend(harFile, null, zipFile);
   } else {
     const harFile = JSON.parse(await fs.promises.readFile(params.file, 'utf-8')) as har.HARFile;
-    harBackend = new HarBackend(platform, harFile, path.dirname(params.file), null);
+    harBackend = new HarBackend(harFile, path.dirname(params.file), null);
   }
   harBackends.set(harBackend.id, harBackend);
   return { harId: harBackend.id };
@@ -194,8 +194,8 @@ export async function tracingStarted(stackSessions: Map<string, StackSession>, p
   return { stacksId: traceStacksFile };
 }
 
-export async function traceDiscarded(platform: Platform, stackSessions: Map<string, StackSession>, params: channels.LocalUtilsTraceDiscardedParams): Promise<void> {
+export async function traceDiscarded(stackSessions: Map<string, StackSession>, params: channels.LocalUtilsTraceDiscardedParams): Promise<void> {
-  await deleteStackSession(platform, stackSessions, params.stacksId);
+  await deleteStackSession(stackSessions, params.stacksId);
 }
 
 export async function addStackToTracingNoReply(stackSessions: Map<string, StackSession>, params: channels.LocalUtilsAddStackToTracingNoReplyParams): Promise<void> {

packages/playwright-core/src/server/page.ts

@@ -28,12 +28,12 @@ import { parseEvaluationResultValue, source } from './isomorphic/utilityScriptSe
 import * as js from './javascript';
 import { ProgressController } from './progress';
 import { Screenshotter, validateScreenshotOptions } from './screenshotter';
-import { TimeoutSettings } from '../common/timeoutSettings';
+import { TimeoutSettings } from '../utils/isomorphic/timeoutSettings';
 import { LongStandingScope, assert, compressCallLog, trimStringWithEllipsis } from '../utils';
 import { createGuid } from './utils/crypto';
 import { asLocator } from '../utils';
 import { getComparator } from './utils/comparators';
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from './utils/debugLogger';
 import { isInvalidSelectorError } from '../utils/isomorphic/selectorParser';
 import { ManualPromise } from '../utils/isomorphic/manualPromise';
 

packages/playwright-core/src/server/pipeTransport.ts

@@ -16,7 +16,7 @@
  */
 
 import { makeWaitForNextTask } from '../utils';
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from './utils/debugLogger';
 
 import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from './transport';
 

packages/playwright-core/src/server/progress.ts

@@ -19,10 +19,14 @@ import { assert, monotonicTime } from '../utils';
 import { ManualPromise } from '../utils/isomorphic/manualPromise';
 
 import type { CallMetadata, Instrumentation, SdkObject } from './instrumentation';
-import type { Progress as CommonProgress } from '../common/progress';
+import type { LogName } from './utils/debugLogger';
-import type { LogName } from '../utils/debugLogger';
 
-export interface Progress extends CommonProgress {
+export interface Progress {
+  log(message: string): void;
+  timeUntilDeadline(): number;
+  isRunning(): boolean;
+  cleanupWhenAborted(cleanup: () => any): void;
+  throwIfAborted(): void;
   metadata: CallMetadata;
 }
 

packages/playwright-core/src/server/protocolError.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { rewriteErrorMessage } from '../utils/stackTrace';
+import { rewriteErrorMessage } from '../utils/isomorphic/stackTrace';
 
 export class ProtocolError extends Error {
   type: 'error' | 'closed' | 'crashed';

packages/playwright-core/src/server/recorder/recorderCollection.ts

@@ -18,7 +18,7 @@ import { EventEmitter } from 'events';
 
 import { performAction } from './recorderRunner';
 import { collapseActions } from './recorderUtils';
-import { isUnderTest } from '../../utils/debug';
+import { isUnderTest } from '../../utils/isomorphic/debug';
 import { monotonicTime } from '../../utils/isomorphic/time';
 
 import type { Signal } from '../../../../recorder/src/actions';

packages/playwright-core/src/server/registry/browserFetcher.ts

@@ -20,10 +20,10 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 import { ManualPromise } from '../../utils/isomorphic/manualPromise';
-import { getUserAgent } from '../../utils/userAgent';
+import { getUserAgent } from '../utils/userAgent';
-import { colors, progress as ProgressBar } from '../../utilsBundle';
+import { progress as ProgressBar, colors } from '../../utilsBundle';
 import { existsAsync } from '../utils/fileUtils';
 
 import { browserDirectoryToMarkerFilePath } from '.';

packages/playwright-core/src/server/registry/dependencies.ts

@@ -21,9 +21,9 @@ import * as path from 'path';
 
 import { deps } from './nativeDeps';
 import { wrapInASCIIBox } from '../utils/ascii';
-import { hostPlatform, isOfficiallySupportedPlatform } from '../../utils/hostPlatform';
+import { hostPlatform, isOfficiallySupportedPlatform } from '../utils/hostPlatform';
 import { spawnAsync } from '../utils/spawnAsync';
-import { getPlaywrightVersion } from '../../utils/userAgent';
+import { getPlaywrightVersion } from '../utils/userAgent';
 
 import { buildPlaywrightCLICommand, registry } from '.';
 

packages/playwright-core/src/server/registry/index.ts

@@ -25,16 +25,16 @@ import { dockerVersion, readDockerVersionSync, transformCommandsForRoot } from '
 import { installDependenciesLinux, installDependenciesWindows, validateDependenciesLinux, validateDependenciesWindows } from './dependencies';
 import { calculateSha1, getAsBooleanFromENV, getFromENV, getPackageManagerExecCommand } from '../../utils';
 import { wrapInASCIIBox } from '../utils/ascii';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
-import {  hostPlatform, isOfficiallySupportedPlatform } from '../../utils/hostPlatform';
+import {  hostPlatform, isOfficiallySupportedPlatform } from '../utils/hostPlatform';
 import { fetchData } from '../utils/network';
 import { spawnAsync } from '../utils/spawnAsync';
-import { getEmbedderName } from '../../utils/userAgent';
+import { getEmbedderName } from '../utils/userAgent';
 import { lockfile } from '../../utilsBundle';
 import { canAccessFile, existsAsync, removeFolders } from '../utils/fileUtils';
 
 import type { DependencyGroup } from './dependencies';
-import type { HostPlatform } from '../../utils/hostPlatform';
+import type { HostPlatform } from '../utils/hostPlatform';
 
 export { writeDockerVersion } from './dependencies';
 

packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts

@@ -24,7 +24,7 @@ import { SocksProxy } from './utils/socksProxy';
 import { ManualPromise, escapeHTML, generateSelfSignedCertificate, rewriteErrorMessage } from '../utils';
 import { verifyClientCertificates } from './browserContext';
 import { createProxyAgent } from './fetch';
-import { debugLogger } from '../utils/debugLogger';
+import { debugLogger } from './utils/debugLogger';
 import { createSocket, createTLSSocket } from './utils/happyEyeballs';
 
 import type * as types from './types';

packages/playwright-core/src/server/trace/recorder/snapshotter.ts

@@ -17,7 +17,7 @@
 import { frameSnapshotStreamer } from './snapshotterInjected';
 import { monotonicTime } from '../../../utils/isomorphic/time';
 import { calculateSha1, createGuid } from '../../utils/crypto';
-import { debugLogger } from '../../../utils/debugLogger';
+import { debugLogger } from '../../utils/debugLogger';
 import { eventsHelper } from '../../utils/eventsHelper';
 import { mime } from '../../../utilsBundle';
 import { BrowserContext } from '../../browserContext';

packages/playwright-core/src/server/trace/recorder/tracing.ts

@@ -20,7 +20,7 @@ import * as path from 'path';
 
 import { Snapshotter } from './snapshotter';
 import { commandsWithTracingSnapshots } from '../../../protocol/debug';
-import { assert } from '../../../utils/debug';
+import { assert } from '../../../utils/isomorphic/debug';
 import { monotonicTime } from '../../../utils/isomorphic/time';
 import { eventsHelper  } from '../../utils/eventsHelper';
 import { createGuid  } from '../../utils/crypto';

packages/playwright-core/src/server/utils/DEPS.list

@@ -1,4 +1,5 @@
 [*]
+../../common
 ../../utils
 ../../utils/isomorphic
 ../../utilsBundle.ts

packages/playwright-core/src/server/utils/comparators.ts

@@ -18,8 +18,8 @@
 import { compare } from './image_tools/compare';
 // @ts-ignore
 import pixelmatch from '../../third_party/pixelmatch';
-import { colors, jpegjs } from '../../utilsBundle';
+import { jpegjs } from '../../utilsBundle';
-import { diff } from '../../utilsBundle';
+import { colors, diff } from '../../utilsBundle';
 import { PNG } from '../../utilsBundle';
 
 export type ImageComparatorOptions = { threshold?: number, maxDiffPixels?: number, maxDiffPixelRatio?: number, comparator?: string };

packages/playwright-core/src/server/utils/crypto.ts

@@ -16,7 +16,7 @@
 
 import * as crypto from 'crypto';
 
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 
 export function createGuid(): string {
   return crypto.randomBytes(16).toString('hex');

packages/playwright-core/src/server/utils/debugLogger.ts

@@ -16,7 +16,7 @@
 
 import * as fs from 'fs';
 
-import { debug } from '../utilsBundle';
+import { debug } from '../../utilsBundle';
 
 const debugLoggerColorMap = {
   'api': 45, // cyan

packages/playwright-core/src/server/utils/happyEyeballs.ts

@@ -20,7 +20,7 @@ import * as https from 'https';
 import * as net from 'net';
 import * as tls from 'tls';
 
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 import { ManualPromise } from '../../utils/isomorphic/manualPromise';
 import { monotonicTime } from '../../utils/isomorphic/time';
 

packages/playwright-core/src/server/utils/httpServer.ts

@@ -19,7 +19,7 @@ import * as path from 'path';
 
 import { mime, wsServer } from '../../utilsBundle';
 import { createGuid } from './crypto';
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 import { ManualPromise } from '../../utils/isomorphic/manualPromise';
 import { createHttpServer } from './network';
 

packages/playwright-core/src/server/utils/linuxUtils.ts

@@ -23,26 +23,6 @@ let osRelease: {
   version: string,
 } | undefined;
 
-export async function getLinuxDistributionInfo(): Promise<{ id: string, version: string } | undefined> {
-  if (process.platform !== 'linux')
-    return undefined;
-  if (!osRelease && !didFailToReadOSRelease) {
-    try {
-      // List of /etc/os-release values for different distributions could be
-      // found here: https://gist.github.com/aslushnikov/8ceddb8288e4cf9db3039c02e0f4fb75
-      const osReleaseText = await fs.promises.readFile('/etc/os-release', 'utf8');
-      const fields = parseOSReleaseText(osReleaseText);
-      osRelease = {
-        id: fields.get('id') ?? '',
-        version: fields.get('version_id') ?? '',
-      };
-    } catch (e) {
-      didFailToReadOSRelease = true;
-    }
-  }
-  return osRelease;
-}
-
 export function getLinuxDistributionInfoSync(): { id: string, version: string } | undefined {
   if (process.platform !== 'linux')
     return undefined;

packages/playwright-core/src/server/utils/nodePlatform.ts

@@ -19,51 +19,70 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as util from 'util';
 
-export type Platform = {
+import { colors } from '../../utilsBundle';
-  calculateSha1(text: string): Promise<string>;
+import { debugLogger } from './debugLogger';
-  createGuid: () => string;
+import { currentZone, emptyZone } from './zones';
-  fs: () => typeof fs;
+
-  inspectCustom: symbol | undefined;
+import type { Platform, Zone } from '../../common/platform';
-  path: () => typeof path;
+import type { Zone as ZoneImpl } from './zones';
-  ws?: (url: string) => WebSocket;
+
-};
+class NodeZone implements Zone {
+  private _zone: ZoneImpl;
+
+  constructor(zone: ZoneImpl) {
+    this._zone = zone;
+  }
+
+  push<T>(data: T) {
+    return new NodeZone(this._zone.with('apiZone', data));
+  }
+
+  pop() {
+    return new NodeZone(this._zone.without('apiZone'));
+  }
+
+  run<R>(func: () => R): R {
+    return this._zone.run(func);
+  }
+
+  data<T>(): T | undefined {
+    return this._zone.data('apiZone');
+  }
+}
 
 export const nodePlatform: Platform = {
+  name: 'node',
+
   calculateSha1: (text: string) => {
     const sha1 = crypto.createHash('sha1');
     sha1.update(text);
     return Promise.resolve(sha1.digest('hex'));
   },
 
+  colors,
+
   createGuid: () => crypto.randomBytes(16).toString('hex'),
 
   fs: () => fs,
 
   inspectCustom: util.inspect.custom,
 
+  isDebuggerAttached: () => !!require('inspector').url(),
+
+  isLogEnabled(name: 'api' | 'channel') {
+    return debugLogger.isEnabled(name);
+  },
+
+  log(name: 'api' | 'channel', message: string | Error | object) {
+    debugLogger.log(name, message);
+  },
+
   path: () => path,
-};
+
-
+  pathSeparator: path.sep,
-export const webPlatform: Platform = {
+
-  calculateSha1: async (text: string) => {
+  zones: {
-    const bytes = new TextEncoder().encode(text);
+    current: () => new NodeZone(currentZone()),
-    const hashBuffer = await crypto.subtle.digest('SHA-1', bytes);
+    empty: new NodeZone(emptyZone),
-    return Array.from(new Uint8Array(hashBuffer), b => b.toString(16).padStart(2, '0')).join('');
+  }
-  },
-
-  createGuid: () => {
-    return Array.from(crypto.getRandomValues(new Uint8Array(16)), b => b.toString(16).padStart(2, '0')).join('');
-  },
-
-  fs: () => {
-    throw new Error('File system is not available');
-  },
-
-  inspectCustom: undefined,
-
-  path: () => {
-    throw new Error('Path module is not available');
-  },
-
-  ws: (url: string) => new WebSocket(url),
 };

packages/playwright-core/src/server/utils/socksProxy.ts

@@ -17,9 +17,9 @@
 import EventEmitter from 'events';
 import * as net from 'net';
 
-import { assert } from '../../utils/debug';
+import { assert } from '../../utils/isomorphic/debug';
 import { createGuid } from './crypto';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from './debugLogger';
 import { createSocket } from './happyEyeballs';
 
 import type { AddressInfo } from 'net';

packages/playwright-core/src/server/utils/userAgent.ts

@@ -77,6 +77,6 @@ export function getEmbedderName(): { embedderName: string, embedderVersion: stri
 }
 
 export function getPlaywrightVersion(majorMinorOnly = false): string {
-  const version = process.env.PW_VERSION_OVERRIDE || require('./../../package.json').version;
+  const version = process.env.PW_VERSION_OVERRIDE || require('./../../../package.json').version;
   return majorMinorOnly ? version.split('.').slice(0, 2).join('.') : version;
 }

packages/playwright-core/src/server/utils/wsServer.ts

@@ -16,7 +16,7 @@
 
 import { createHttpServer } from './network';
 import { wsServer } from '../../utilsBundle';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from './debugLogger';
 
 import type { WebSocket, WebSocketServer } from '../../utilsBundle';
 import type http from 'http';

packages/playwright-core/src/server/utils/zipFile.ts

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-import { yauzl } from '../zipBundle';
+import { yauzl } from '../../zipBundle';
 
-import type { Entry, UnzipFile } from '../zipBundle';
+import type { Entry, UnzipFile } from '../../zipBundle';
 
 export class ZipFile {
   private _fileName: string;

packages/playwright-core/src/server/utils/zones.ts

@@ -18,36 +18,13 @@ import { AsyncLocalStorage } from 'async_hooks';
 
 export type ZoneType = 'apiZone' | 'stepZone';
 
-class ZoneManager {
+const asyncLocalStorage = new AsyncLocalStorage<Zone | undefined>();
-  private readonly _asyncLocalStorage = new AsyncLocalStorage<Zone | undefined>();
-  private readonly _emptyZone = Zone.createEmpty(this._asyncLocalStorage);
-
-  run<T, R>(type: ZoneType, data: T, func: () => R): R {
-    return this.current().with(type, data).run(func);
-  }
-
-  zoneData<T>(type: ZoneType): T | undefined {
-    return this.current().data(type);
-  }
-
-  current(): Zone {
-    return this._asyncLocalStorage.getStore() ?? this._emptyZone;
-  }
-
-  empty(): Zone {
-    return this._emptyZone;
-  }
-}
 
 export class Zone {
   private readonly _asyncLocalStorage: AsyncLocalStorage<Zone | undefined>;
   private readonly _data: ReadonlyMap<ZoneType, unknown>;
 
-  static createEmpty(asyncLocalStorage: AsyncLocalStorage<Zone | undefined>) {
+  constructor(asyncLocalStorage: AsyncLocalStorage<Zone | undefined>, store: Map<ZoneType, unknown>) {
-    return new Zone(asyncLocalStorage, new Map());
-  }
-
-  private constructor(asyncLocalStorage: AsyncLocalStorage<Zone | undefined>, store: Map<ZoneType, unknown>) {
     this._asyncLocalStorage = asyncLocalStorage;
     this._data = store;
   }
@@ -71,4 +48,8 @@ export class Zone {
   }
 }
 
-export const zones = new ZoneManager();
+export const emptyZone = new Zone(asyncLocalStorage, new Map());
+
+export function currentZone(): Zone {
+  return asyncLocalStorage.getStore() ?? emptyZone;
+}

packages/playwright-core/src/server/webkit/wkConnection.ts

@@ -18,13 +18,13 @@
 import { EventEmitter } from 'events';
 
 import { assert } from '../../utils';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 import { helper } from '../helper';
 import { ProtocolError } from '../protocolError';
 
 import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
 import type { Protocol } from './protocol';
-import type { RecentLogsCollector } from '../../utils/debugLogger';
+import type { RecentLogsCollector } from '../utils/debugLogger';
 import type { ProtocolLogger } from '../types';
 
 

packages/playwright-core/src/server/webkit/wkPage.ts

@@ -21,8 +21,8 @@ import { assert, debugAssert } from '../../utils';
 import { headersArrayToObject } from '../../utils/isomorphic/headers';
 import { createGuid } from '../utils/crypto';
 import { eventsHelper } from '../utils/eventsHelper';
-import { hostPlatform } from '../../utils/hostPlatform';
+import { hostPlatform } from '../utils/hostPlatform';
-import { splitErrorMessage } from '../../utils/stackTrace';
+import { splitErrorMessage } from '../../utils/isomorphic/stackTrace';
 import { PNG, jpegjs } from '../../utilsBundle';
 import { BrowserContext } from '../browserContext';
 import * as dialog from '../dialog';
@@ -39,7 +39,7 @@ import { RawKeyboardImpl, RawMouseImpl, RawTouchscreenImpl } from './wkInput';
 import { WKInterceptableRequest, WKRouteImpl } from './wkInterceptableRequest';
 import { WKProvisionalPage } from './wkProvisionalPage';
 import { WKWorkers } from './wkWorkers';
-import { debugLogger } from '../../utils/debugLogger';
+import { debugLogger } from '../utils/debugLogger';
 
 import type { Protocol } from './protocol';
 import type { WKBrowserContext } from './wkBrowser';

packages/playwright-core/src/utils.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+export * from './utils/isomorphic/colors';
+export * from './utils/isomorphic/debug';
 export * from './utils/isomorphic/locatorGenerators';
 export * from './utils/isomorphic/manualPromise';
 export * from './utils/isomorphic/mimeType';
@@ -24,29 +26,30 @@ export * from './utils/isomorphic/time';
 export * from './utils/isomorphic/timeoutRunner';
 export * from './utils/isomorphic/urlMatch';
 
-export * from './utils/debug';
-export * from './utils/debugLogger';
-export * from './utils/env';
-export * from './utils/hostPlatform';
 export * from './utils/isomorphic/headers';
 export * from './utils/isomorphic/semaphore';
-export * from './utils/platform';
+export * from './utils/isomorphic/stackTrace';
-export * from './utils/stackTrace';
-export * from './utils/task';
-export * from './utils/userAgent';
-export * from './utils/zipFile';
-export * from './utils/zones';
 
 export * from './server/utils/ascii';
 export * from './server/utils/comparators';
 export * from './server/utils/crypto';
+export * from './server/utils/debugLogger';
+export * from './server/utils/env';
 export * from './server/utils/eventsHelper';
 export * from './server/utils/expectUtils';
 export * from './server/utils/fileUtils';
+export * from './server/utils/hostPlatform';
 export * from './server/utils/httpServer';
 export * from './server/utils/network';
+export * from './server/utils/nodePlatform';
 export * from './server/utils/processLauncher';
 export * from './server/utils/profiler';
 export * from './server/utils/socksProxy';
 export * from './server/utils/spawnAsync';
+export * from './server/utils/task';
+export * from './server/utils/userAgent';
 export * from './server/utils/wsServer';
+export * from './server/utils/zipFile';
+export * from './server/utils/zones';
+
+export { colors } from './utilsBundle';

packages/playwright-core/src/utils/isomorphic/colors.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export const webColors = {
+  enabled: true,
+  reset: (text: string) => applyStyle(0, 0, text),
+
+  bold: (text: string) => applyStyle(1, 22, text),
+  dim: (text: string) => applyStyle(2, 22, text),
+  italic: (text: string) => applyStyle(3, 23, text),
+  underline: (text: string) => applyStyle(4, 24, text),
+  inverse: (text: string) => applyStyle(7, 27, text),
+  hidden: (text: string) => applyStyle(8, 28, text),
+  strikethrough: (text: string) => applyStyle(9, 29, text),
+
+  black: (text: string) => applyStyle(30, 39, text),
+  red: (text: string) => applyStyle(31, 39, text),
+  green: (text: string) => applyStyle(32, 39, text),
+  yellow: (text: string) => applyStyle(33, 39, text),
+  blue: (text: string) => applyStyle(34, 39, text),
+  magenta: (text: string) => applyStyle(35, 39, text),
+  cyan: (text: string) => applyStyle(36, 39, text),
+  white: (text: string) => applyStyle(37, 39, text),
+  gray: (text: string) => applyStyle(90, 39, text),
+  grey: (text: string) => applyStyle(90, 39, text),
+};
+
+export type Colors = typeof webColors;
+
+export const noColors: Colors = {
+  enabled: false,
+  reset: t => t,
+  bold: t => t,
+  dim: t => t,
+  italic: t => t,
+  underline: t => t,
+  inverse: t => t,
+  hidden: t => t,
+  strikethrough: t => t,
+  black: t => t,
+  red: t => t,
+  green: t => t,
+  yellow: t => t,
+  blue: t => t,
+  magenta: t => t,
+  cyan: t => t,
+  white: t => t,
+  gray: t => t,
+  grey: t => t,
+};
+
+
+const applyStyle = (open: number, close: number, text: string) => `\u001b[${open}m${text}\u001b[${close}m`;

packages/playwright-core/src/utils/isomorphic/debug.ts

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { getFromENV } from './env';
-
 export function assert(value: any, message?: string): asserts value {
   if (!value)
     throw new Error(message || 'Assertion error');
@@ -26,13 +24,18 @@ export function debugAssert(value: any, message?: string): asserts value {
     throw new Error(message);
 }
 
-const debugEnv = getFromENV('PWDEBUG') || '';
+let _debugMode: string | undefined;
+
+export function setDebugMode(mode: string) {
+  _debugMode = mode;
+}
+
 export function debugMode() {
-  if (debugEnv === 'console')
+  if (_debugMode === 'console')
     return 'console';
-  if (debugEnv === '0' || debugEnv === 'false')
+  if (_debugMode === '0' || _debugMode === 'false')
     return '';
-  return debugEnv ? 'inspector' : '';
+  return _debugMode ? 'inspector' : '';
 }
 
 let _isUnderTest = !!process.env.PWTEST_UNDER_TEST;