chore: lazy-load modules, add module profiling and json schema validator

Author: pavelfeldman

packages/playwright-core/package.json

@@ -22,6 +22,7 @@
       "default": "./index.js"
     },
     "./package.json": "./package.json",
+    "./lib/bootstrap": "./lib/bootstrap.js",
     "./lib/outofprocess": "./lib/outofprocess.js",
     "./lib/cli/program": "./lib/cli/program.js",
     "./lib/tools/cli-client/program": "./lib/tools/cli-client/program.js",

packages/playwright-core/src/bootstrap.ts

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+if (process.env.PW_INSTRUMENT_MODULES) {
+  const Module = require('module');
+  const originalLoad = Module._load;
+
+  type TreeNode = { name: string, selfMs: number, totalMs: number, childrenMs: number, children: TreeNode[] };
+  const root: TreeNode = { name: '<root>', selfMs: 0, totalMs: 0, childrenMs: 0, children: [] };
+  let current = root;
+  const stack: TreeNode[] = [];
+
+  Module._load = function(request: any, _parent: any, _isMain: any) {
+    const node: TreeNode = { name: request, selfMs: 0, totalMs: 0, childrenMs: 0, children: [] };
+    current.children.push(node);
+    stack.push(current);
+    current = node;
+    const start = performance.now();
+    let result;
+    try {
+      result = originalLoad.apply(this, arguments);
+    } catch (e) {
+      // Module load failed (e.g. optional dep not found) — unwind stack.
+      current = stack.pop()!;
+      current.children.pop();
+      throw e;
+    }
+    const duration = performance.now() - start;
+    node.totalMs = duration;
+    node.selfMs = Math.max(0, duration - node.childrenMs);
+    current = stack.pop()!;
+    current.childrenMs += duration;
+    return result;
+  };
+
+  process.on('exit', () => {
+    function printTree(node: TreeNode, prefix: string, isLast: boolean, lines: string[], depth: number) {
+      if (node.totalMs < 1 && depth > 0)
+        return;
+      const connector = depth === 0 ? '' : isLast ? '└── ' : '├── ';
+      const time = `${node.totalMs.toFixed(1).padStart(8)}ms`;
+      const self = node.children.length ? ` (self: ${node.selfMs.toFixed(1)}ms)` : '';
+      lines.push(`${time}  ${prefix}${connector}${node.name}${self}`);
+      const childPrefix = prefix + (depth === 0 ? '' : isLast ? '    ' : '│   ');
+      const sorted = node.children.slice().sort((a, b) => b.totalMs - a.totalMs);
+      for (let i = 0; i < sorted.length; i++)
+        printTree(sorted[i], childPrefix, i === sorted.length - 1, lines, depth + 1);
+    }
+
+    let totalModules = 0;
+    function count(n: TreeNode) { totalModules++; n.children.forEach(count); }
+    root.children.forEach(count);
+
+    const lines: string[] = [];
+    const sorted = root.children.slice().sort((a, b) => b.totalMs - a.totalMs);
+    for (let i = 0; i < sorted.length; i++)
+      printTree(sorted[i], '', i === sorted.length - 1, lines, 0);
+
+    const totalMs = root.children.reduce((s, c) => s + c.totalMs, 0);
+    process.stderr.write(`\n--- Module load tree: ${totalModules} modules, ${totalMs.toFixed(0)}ms total ---\n` + lines.join('\n') + '\n');
+
+    // Flat list: aggregate selfMs across all tree nodes by name.
+    const flat = new Map<string, { selfMs: number, totalMs: number, count: number }>();
+    function gather(n: TreeNode) {
+      const existing = flat.get(n.name);
+      if (existing) {
+        existing.selfMs += n.selfMs;
+        existing.totalMs += n.totalMs;
+        existing.count++;
+      } else {
+        flat.set(n.name, { selfMs: n.selfMs, totalMs: n.totalMs, count: 1 });
+      }
+      n.children.forEach(gather);
+    }
+    root.children.forEach(gather);
+    const top50 = [...flat.entries()].sort((a, b) => b[1].selfMs - a[1].selfMs).slice(0, 50);
+    const flatLines = top50.map(([mod, { selfMs, totalMs, count }]) =>
+      `${selfMs.toFixed(1).padStart(8)}ms self ${totalMs.toFixed(1).padStart(8)}ms total  (x${String(count).padStart(3)})  ${mod}`
+    );
+    process.stderr.write(`\n--- Top 50 modules by self time ---\n` + flatLines.join('\n') + '\n');
+  });
+}

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

@@ -16,6 +16,7 @@
 
 /* eslint-disable no-console */
 
+import '../bootstrap';
 import { gracefullyProcessExitDoNotHang, getPackageManagerExecCommand } from '../utils';
 import { addTraceCommands } from '../tools/trace/traceCli';
 import { program } from '../utilsBundle';

packages/playwright-core/src/server/har/harRecorder.ts

@@ -21,7 +21,6 @@ import { Artifact } from '../artifact';
 import { HarTracer } from './harTracer';
 import { createGuid } from '../utils/crypto';
 import { ManualPromise } from '../../utils/isomorphic/manualPromise';
-import { yazl } from '../../zipBundle';
 
 import type { BrowserContext } from '../browserContext';
 import type { HarTracerDelegate } from './harTracer';
@@ -52,6 +51,7 @@ export class HarRecorder implements HarTracerDelegate {
       waitForContentOnStop: true,
       urlFilter: urlFilterRe ?? options.urlGlob,
     });
+    const { yazl } = require('../../zipBundle');
     this._zipFile = content === 'attach' || expectsZip ? new yazl.ZipFile() : null;
     this._tracer.start({ omitScripts: false });
   }

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

@@ -22,7 +22,6 @@ import { calculateSha1 } from './utils/crypto';
 import { HarBackend } from './harBackend';
 import { ManualPromise } from '../utils/isomorphic/manualPromise';
 import { ZipFile } from './utils/zipFile';
-import { yauzl, yazl } from '../zipBundle';
 import { serializeClientSideCallMetadata } from '../utils/isomorphic/trace/traceUtils';
 import { assert } from '../utils/isomorphic/assert';
 import { removeFolders } from './utils/fileUtils';
@@ -43,6 +42,7 @@ export type StackSession = {
 
 export async function zip(progress: Progress, stackSessions: Map<string, StackSession>, params: channels.LocalUtilsZipParams): Promise<void> {
   const promise = new ManualPromise<void>();
+  const { yauzl, yazl } = await import('../zipBundle');
   const zipFile = new yazl.ZipFile();
   (zipFile as any as EventEmitter).on('error', error => promise.reject(error));
 

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

@@ -21,7 +21,6 @@ import path from 'path';
 import { calculateSha1 } from './crypto';
 
 import { ManualPromise } from '../../utils/isomorphic/manualPromise';
-import { yazl } from '../../zipBundle';
 
 import type { EventEmitter } from 'events';
 
@@ -201,6 +200,7 @@ export class SerializedFS {
         return;
       }
       case 'zip': {
+        const { yazl } = await import('playwright-core/lib/zipBundle');
         const zipFile = new yazl.ZipFile();
         const result = new ManualPromise<void>();
         (zipFile as any as EventEmitter).on('error', error => result.reject(error));

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

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-import { yauzl } from '../../zipBundle';
-
 import type { Entry, UnzipFile } from '../../zipBundle';
 
 export class ZipFile {
@@ -30,6 +28,7 @@ export class ZipFile {
   }
 
   private async _open() {
+    const { yauzl } = await import('../../zipBundle');
     await new Promise<UnzipFile>((fulfill, reject) => {
       yauzl.open(this._fileName, { autoClose: false }, (e, z) => {
         if (e) {

packages/playwright-core/src/utils.ts

@@ -19,6 +19,7 @@ export * from './utils/isomorphic/assert';
 export * from './utils/isomorphic/colors';
 export * from './utils/isomorphic/headers';
 export * from './utils/isomorphic/imageUtils';
+export * from './utils/isomorphic/jsonSchema';
 export * from './utils/isomorphic/locatorGenerators';
 export * from './utils/isomorphic/manualPromise';
 export * from './utils/isomorphic/mimeType';

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

@@ -0,0 +1,94 @@
+/**
+ * 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 type JsonSchema = {
+  type?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  oneOf?: JsonSchema[];
+  pattern?: string;
+  patternError?: string;
+};
+
+const regexCache = new Map<string, RegExp>();
+
+export function validate(value: unknown, schema: JsonSchema, path: string): string[] {
+  const errors: string[] = [];
+
+  if (schema.oneOf) {
+    let bestErrors: string[] | undefined;
+    for (const variant of schema.oneOf) {
+      const variantErrors = validate(value, variant, path);
+      if (variantErrors.length === 0)
+        return [];
+      // Prefer the variant with fewest errors (closest match).
+      if (!bestErrors || variantErrors.length < bestErrors.length)
+        bestErrors = variantErrors;
+    }
+    return bestErrors!;
+  }
+
+  if (schema.type === 'string') {
+    if (typeof value !== 'string') {
+      errors.push(`${path}: expected string, got ${typeof value}`);
+      return errors;
+    }
+    if (schema.pattern && !cachedRegex(schema.pattern).test(value))
+      errors.push(schema.patternError || `${path}: must match pattern "${schema.pattern}"`);
+    return errors;
+  }
+
+  if (schema.type === 'array') {
+    if (!Array.isArray(value)) {
+      errors.push(`${path}: expected array, got ${typeof value}`);
+      return errors;
+    }
+    if (schema.items) {
+      for (let i = 0; i < value.length; i++)
+        errors.push(...validate(value[i], schema.items, `${path}[${i}]`));
+    }
+    return errors;
+  }
+
+  if (schema.type === 'object') {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      errors.push(`${path}: expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
+      return errors;
+    }
+    const obj = value as Record<string, unknown>;
+    for (const key of schema.required || []) {
+      if (obj[key] === undefined)
+        errors.push(`${path}.${key}: required`);
+    }
+    for (const [key, propSchema] of Object.entries(schema.properties || {})) {
+      if (obj[key] !== undefined)
+        errors.push(...validate(obj[key], propSchema, `${path}.${key}`));
+    }
+    return errors;
+  }
+
+  return errors;
+}
+
+function cachedRegex(pattern: string): RegExp {
+  let regex = regexCache.get(pattern);
+  if (!regex) {
+    regex = new RegExp(pattern);
+    regexCache.set(pattern, regex);
+  }
+  return regex;
+}

packages/playwright/src/common/process.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import 'playwright-core/lib/bootstrap';
 import { ManualPromise, setTimeOrigin, startProfiling, stopProfiling } from 'playwright-core/lib/utils';
 
 import { serializeError } from '../util';