@xylentis/testgen 0.0.0-stage → 1.1.0

package/dist/generators/selenium-java.js

@@ -0,0 +1,257 @@
+import { isRegex, parseLocator } from '../locator.js';
+import { camelCase, pascalCase } from '../naming.js';
+import { PageAliases, isBlankUrl, shortcutOf, signalsOf, toKeyboardModifiers } from '../recording.js';
+import { readRuntime } from './runtime.js';
+import { seleniumBrowser, seleniumDriverOptions } from './selenium-common.js';
+import { CodeWriter, doubleQuote } from './writer.js';
+const javaKeywords = new Set(('abstract assert boolean break byte case catch char class const continue default do double else enum ' +
+    'extends final finally float for goto if implements import instanceof int interface long native new package private protected ' +
+    'public return short static strictfp super switch synchronized this throw throws transient try void volatile while var record yield').split(' '));
+export const seleniumJava = {
+    id: 'selenium-java',
+    framework: 'Selenium WebDriver + JUnit 5',
+    language: 'Java',
+    highlight: 'java',
+    testFileName: name => `${pascalCase(name)}Test.java`,
+    generate(recording, options) {
+        const { header } = recording;
+        const locators = new JavaLocators();
+        const body = new CodeWriter('    ');
+        const aliases = new PageAliases();
+        const todo = (message) => body.line(`// TODO(testgen): ${message}`);
+        recording.actions.forEach(actionInContext => {
+            const { action } = actionInContext;
+            const pageAlias = aliases.alias(actionInContext.pageGuid);
+            if (action.name === 'openPage') {
+                if (pageAlias !== 'page')
+                    body.line(`var ${pageAlias} = page.newPage();`);
+                if (!isBlankUrl(action.url))
+                    body.line(`${pageAlias}.navigate(${doubleQuote(action.url)});`);
+                return;
+            }
+            if (action.name === 'closePage') {
+                // The driver quits after the test; only pages opened later are closed explicitly.
+                if (pageAlias !== 'page')
+                    body.line(`${pageAlias}.close();`);
+                return;
+            }
+            const signals = signalsOf(actionInContext);
+            if (signals.dialog) {
+                body.block(`${pageAlias}.onceDialog(dialog -> {`, () => {
+                    body.line('System.out.println("Dialog message: " + dialog.message());');
+                    body.line('dialog.dismiss();');
+                }, '});');
+            }
+            if (signals.download)
+                todo('the next step starts a download, which Selenium cannot wait for.');
+            if (action.name === 'assertSnapshot')
+                todo('aria snapshot assertions are not available on Selenium; checking visibility instead.');
+            const call = actionCall(pageAlias, action, locators);
+            if (signals.popup)
+                body.line(`var ${aliases.alias(signals.popup.popupPageGuid)} = ${pageAlias}.waitForPopup(() -> ${call});`);
+            else
+                body.line(`${call};`);
+            if (header.generateExpectSignal && signals.expect)
+                body.line(`${locators.render(pageAlias, parseLocator(signals.expect.selector))}.shouldBeVisible();`);
+        });
+        const driverOptions = seleniumDriverOptions(header);
+        const className = `${pascalCase(options.name)}Test`;
+        const methodName = javaKeywords.has(camelCase(options.name)) ? `test${pascalCase(options.name)}` : camelCase(options.name);
+        const packageName = options.packageName;
+        const w = new CodeWriter('    ');
+        if (packageName) {
+            w.line(`package ${packageName};`);
+            w.line();
+        }
+        if (locators.usesMap)
+            w.line('import java.util.Map;');
+        if (locators.usesPattern)
+            w.line('import java.util.regex.Pattern;');
+        w.line('import org.junit.jupiter.api.AfterEach;');
+        w.line('import org.junit.jupiter.api.BeforeEach;');
+        w.line('import org.junit.jupiter.api.Test;');
+        w.line('import org.openqa.selenium.WebDriver;');
+        w.line();
+        w.line('// Generated by testgen from a Playwright recording; runs on Selenium WebDriver.');
+        w.line('// TestgenSupport.java (same package) provides Playwright-style locators with auto-waiting.');
+        w.block(`class ${className} {`, () => {
+            w.line('private WebDriver driver;');
+            w.line('private TestgenSupport.Page page;');
+            w.line();
+            w.line('@BeforeEach');
+            w.block('void setUp() {', () => {
+                if (driverOptions.unsupported.length)
+                    w.line(`// TODO(testgen): not applied on Selenium: ${driverOptions.unsupported.join(', ')}.`);
+                const args = [doubleQuote(seleniumBrowser(header)), ...driverOptions.args.map(doubleQuote)];
+                w.line(`driver = TestgenSupport.createDriver(${args.join(', ')});`);
+                if (driverOptions.viewport)
+                    w.line(`TestgenSupport.setViewportSize(driver, ${driverOptions.viewport.width}, ${driverOptions.viewport.height});`);
+                w.line('page = new TestgenSupport.Page(driver);');
+                if (options.testIdAttribute !== 'data-testid')
+                    w.line(`page.setTestIdAttribute(${doubleQuote(options.testIdAttribute)});`);
+            });
+            w.line();
+            w.line('@AfterEach');
+            w.block('void tearDown() {', () => {
+                w.line('if (driver != null)');
+                w.line('    driver.quit();');
+            });
+            w.line();
+            w.line('@Test');
+            w.block(`void ${methodName}() {`, () => w.line(body.toString().trimEnd()));
+        });
+        const support = readRuntime('selenium-java/TestgenSupport.java', engine => engine.replace(/\\/g, '\\\\'))
+            .replace('/* @testgen-package */', packageName ? `package ${packageName};` : '');
+        return [
+            { path: `${className}.java`, content: w.toString() },
+            { path: 'TestgenSupport.java', content: support.replace(/^\n+/, ''), support: true },
+        ];
+    },
+};
+function actionCall(subject, action, locators) {
+    const locator = 'selector' in action ? locators.render(subject, parseLocator(action.selector)) : subject;
+    switch (action.name) {
+        case 'click': {
+            if (action.clickCount === 2 && action.button === 'left' && !action.modifiers && !action.position)
+                return `${locator}.dblclick()`;
+            const options = [];
+            if (action.button !== 'left')
+                options.push(`.setButton(${doubleQuote(action.button)})`);
+            const modifiers = toKeyboardModifiers(action.modifiers);
+            if (modifiers.length)
+                options.push(`.setModifiers(${modifiers.map(doubleQuote).join(', ')})`);
+            if (action.clickCount > 1)
+                options.push(`.setClickCount(${action.clickCount})`);
+            if (action.position)
+                options.push(`.setPosition(${action.position.x}, ${action.position.y})`);
+            return options.length ? `${locator}.click(new TestgenSupport.ClickOptions()${options.join('')})` : `${locator}.click()`;
+        }
+        case 'hover':
+            return action.position
+                ? `${locator}.hover(new TestgenSupport.ClickOptions().setPosition(${action.position.x}, ${action.position.y}))`
+                : `${locator}.hover()`;
+        case 'check':
+            return `${locator}.check()`;
+        case 'uncheck':
+            return `${locator}.uncheck()`;
+        case 'fill':
+            return `${locator}.fill(${doubleQuote(action.text)})`;
+        case 'setInputFiles':
+            return `${locator}.setInputFiles(${action.files.map(doubleQuote).join(', ')})`;
+        case 'press':
+            return `${locator}.press(${doubleQuote(shortcutOf(action))})`;
+        case 'navigate':
+            return `${subject}.navigate(${doubleQuote(action.url)})`;
+        case 'select':
+            return `${locator}.selectOption(${action.options.map(doubleQuote).join(', ')})`;
+        case 'assertText':
+            return `${locator}.${action.substring ? 'shouldContainText' : 'shouldHaveText'}(${doubleQuote(action.text)})`;
+        case 'assertChecked':
+            return `${locator}.${action.checked ? 'shouldBeChecked' : 'shouldNotBeChecked'}()`;
+        case 'assertVisible':
+        case 'assertSnapshot':
+            return `${locator}.shouldBeVisible()`;
+        case 'assertValue':
+            return action.value ? `${locator}.shouldHaveValue(${doubleQuote(action.value)})` : `${locator}.shouldBeEmpty()`;
+        case 'openPage':
+        case 'closePage':
+            throw new Error(`${action.name} is handled by the caller`);
+    }
+}
+// Renders Playwright locator steps as calls on TestgenSupport.Locator.
+class JavaLocators {
+    usesMap = false;
+    usesPattern = false;
+    render(subject, steps) {
+        return subject + steps.map(step => '.' + this._step(subject, step)).join('');
+    }
+    _value(matcher) {
+        if (!isRegex(matcher))
+            return doubleQuote(matcher);
+        this.usesPattern = true;
+        const flags = [['i', 'CASE_INSENSITIVE'], ['m', 'MULTILINE'], ['s', 'DOTALL']]
+            .filter(([flag]) => matcher.flags.includes(flag))
+            .map(([, name]) => `Pattern.${name}`);
+        return `Pattern.compile(${doubleQuote(matcher.source)}${flags.length ? ', ' + flags.join(' | ') : ''})`;
+    }
+    _step(subject, step) {
+        const body = step.body;
+        switch (step.kind) {
+            case 'default':
+                if (/^visible=(true|false)$/.test(body))
+                    return `filterVisible(${body.endsWith('true')})`;
+                if (step.hasText !== undefined)
+                    return `locator(${doubleQuote(body)}).filterHasText(${this._value(step.hasText)})`;
+                if (step.hasNotText !== undefined)
+                    return `locator(${doubleQuote(body)}).filterHasNotText(${this._value(step.hasNotText)})`;
+                return `locator(${doubleQuote(body)})`;
+            case 'frame-locator':
+                return `frameLocator(${doubleQuote(body)})`;
+            case 'frame':
+                return 'contentFrame()';
+            case 'any-frame':
+                return `locator(${doubleQuote('internal:control=any-frame')})`;
+            case 'nth':
+                return `nth(${body})`;
+            case 'first':
+                return 'first()';
+            case 'last':
+                return 'last()';
+            case 'visible':
+                return 'filterVisible(true)';
+            case 'filter-visible':
+                return `filterVisible(${body === 'true'})`;
+            case 'has-text':
+                return `filterHasText(${this._value(step.body)})`;
+            case 'has-not-text':
+                return `filterHasNotText(${this._value(step.body)})`;
+            case 'has':
+                return `filterHas(${this.render(subject, step.inner)})`;
+            case 'hasNot':
+                return `filterHasNot(${this.render(subject, step.inner)})`;
+            case 'and':
+                return `and(${this.render(subject, step.inner)})`;
+            case 'or':
+                return `or(${this.render(subject, step.inner)})`;
+            case 'chain':
+                return `locator(${this.render(subject, step.inner)})`;
+            case 'test-id':
+                return `getByTestId(${this._value(step.body)})`;
+            case 'role':
+                return this._role(step);
+            case 'text':
+                return this._byText('getByText', step);
+            case 'alt':
+                return this._byText('getByAltText', step);
+            case 'placeholder':
+                return this._byText('getByPlaceholder', step);
+            case 'label':
+                return this._byText('getByLabel', step);
+            case 'title':
+                return this._byText('getByTitle', step);
+        }
+    }
+    _byText(method, step) {
+        if (step.exact && !isRegex(step.body))
+            return `${method}(${this._value(step.body)}, true)`;
+        return `${method}(${this._value(step.body)})`;
+    }
+    _role(step) {
+        const role = doubleQuote(step.body);
+        const simpleName = typeof step.name === 'string' && !step.exact && !step.attrs?.length && step.description === undefined;
+        if (step.name === undefined && !step.attrs?.length)
+            return `getByRole(${role})`;
+        if (simpleName)
+            return `getByRole(${role}, ${doubleQuote(step.name)})`;
+        const options = [];
+        if (step.name !== undefined)
+            options.push(`"name", ${this._value(step.name)}`);
+        if (step.exact && typeof step.name === 'string')
+            options.push(`"exact", true`);
+        for (const { name, value } of step.attrs ?? [])
+            options.push(`${doubleQuote(name)}, ${typeof value === 'string' ? doubleQuote(value) : value}`);
+        this.usesMap = true;
+        return `getByRole(${role}, Map.of(${options.join(', ')}))`;
+    }
+}
+//# sourceMappingURL=selenium-java.js.map

package/dist/generators/selenium-js.js

@@ -0,0 +1,57 @@
+import { kebabCase, words } from '../naming.js';
+import { writeJavaScriptBody } from './javascript-body.js';
+import { readRuntime } from './runtime.js';
+import { seleniumBrowser, seleniumDriverOptions } from './selenium-common.js';
+import { CodeWriter, singleQuote } from './writer.js';
+export const seleniumJs = {
+    id: 'selenium-js',
+    framework: 'Selenium WebDriver + Mocha',
+    language: 'JavaScript',
+    highlight: 'javascript',
+    testFileName: name => `${kebabCase(name)}.spec.js`,
+    generate(recording, options) {
+        const { header } = recording;
+        const title = singleQuote(words(options.name).join(' '));
+        const driverOptions = seleniumDriverOptions(header);
+        const createOptions = [];
+        if (driverOptions.viewport)
+            createOptions.push(`viewport: { width: ${driverOptions.viewport.width}, height: ${driverOptions.viewport.height} }`);
+        if (driverOptions.args.length)
+            createOptions.push(`args: [${driverOptions.args.map(singleQuote).join(', ')}]`);
+        const createArgs = [singleQuote(seleniumBrowser(header)), ...(createOptions.length ? [`{ ${createOptions.join(', ')} }`] : [])];
+        const attachArgs = ['driver', ...(options.testIdAttribute !== 'data-testid' ? [`{ testIdAttribute: ${singleQuote(options.testIdAttribute)} }`] : [])];
+        const w = new CodeWriter('  ');
+        w.line('// Generated by testgen from a Playwright recording; runs on Selenium WebDriver.');
+        w.line('// testgen-support.js implements the Playwright locator API (getByRole, expect, ...) on top of WebDriver.');
+        w.line(`const { createDriver, Page, expect } = require('./testgen-support');`);
+        w.line();
+        w.block(`describe(${title}, function () {`, () => {
+            w.line('this.timeout(120_000);');
+            w.line('let driver;');
+            w.line('let page;');
+            w.line();
+            w.block('beforeEach(async function () {', () => {
+                if (driverOptions.unsupported.length)
+                    w.line(`// TODO(testgen): not applied on Selenium: ${driverOptions.unsupported.join(', ')}.`);
+                w.line(`driver = await createDriver(${createArgs.join(', ')});`);
+                w.line(`page = await Page.attach(${attachArgs.join(', ')});`);
+            }, '});');
+            w.line();
+            w.block('afterEach(async function () {', () => {
+                w.line('await driver?.quit();');
+            }, '});');
+            w.line();
+            w.block(`it(${title}, async function () {`, () => {
+                writeJavaScriptBody(w, recording, {
+                    supportsDownloads: false,
+                    todo: message => `// TODO(testgen): ${message}`,
+                });
+            }, '});');
+        }, '});');
+        return [
+            { path: this.testFileName(options.name), content: w.toString() },
+            { path: 'testgen-support.js', content: readRuntime('selenium-js/testgen-support.js'), support: true },
+        ];
+    },
+};
+//# sourceMappingURL=selenium-js.js.map

package/dist/generators/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/generators/writer.js

@@ -0,0 +1,38 @@
+import { escapeWithQuotes } from '../vendor/playwright/stringUtils.js';
+// Accumulates indented source lines.
+export class CodeWriter {
+    _unit;
+    _lines = [];
+    _depth = 0;
+    constructor(_unit) {
+        this._unit = _unit;
+    }
+    line(text = '') {
+        for (const line of text.split('\n'))
+            this._lines.push(line ? this._unit.repeat(this._depth) + line : '');
+        return this;
+    }
+    // Adds `open`, the body one level deeper, then `close`.
+    block(open, body, close = '}') {
+        this.line(open);
+        this.indent(body);
+        return this.line(close);
+    }
+    indent(body) {
+        this._depth++;
+        body();
+        this._depth--;
+        return this;
+    }
+    toString() {
+        return this._lines.join('\n') + '\n';
+    }
+}
+// Double-quoted literal valid in Go, Java and JavaScript (JSON escapes are a common subset).
+export function doubleQuote(text) {
+    return JSON.stringify(text);
+}
+export function singleQuote(text) {
+    return escapeWithQuotes(text, '\'');
+}
+//# sourceMappingURL=writer.js.map

package/dist/locator.js

@@ -0,0 +1,49 @@
+import { asLocator, asLocatorWithFactory } from './vendor/playwright/locatorGenerators.js';
+const nestedKinds = ['has', 'hasNot', 'and', 'or', 'chain'];
+export function isRegex(matcher) {
+    return typeof matcher === 'object' && matcher !== null;
+}
+function toMatcher(value) {
+    return value instanceof RegExp ? { source: value.source, flags: value.flags } : value;
+}
+// Playwright decomposes a selector by calling a LocatorFactory per step; this factory
+// records the steps as JSON instead of rendering source code.
+class StepsFactory {
+    generateLocator(base, kind, body, options = {}) {
+        const step = { kind, base, body: '' };
+        if (nestedKinds.includes(kind))
+            step.inner = JSON.parse(body);
+        else
+            step.body = toMatcher(body);
+        if (options.exact !== undefined)
+            step.exact = options.exact;
+        if (options.name !== undefined)
+            step.name = toMatcher(options.name);
+        if (options.description !== undefined)
+            step.description = toMatcher(options.description);
+        if (options.attrs?.length)
+            step.attrs = options.attrs;
+        if (options.hasText !== undefined)
+            step.hasText = toMatcher(options.hasText);
+        if (options.hasNotText !== undefined)
+            step.hasNotText = toMatcher(options.hasNotText);
+        return JSON.stringify([step]);
+    }
+    chainLocators(locators) {
+        return JSON.stringify(locators.flatMap(locator => JSON.parse(locator)));
+    }
+}
+export function parseLocator(selector) {
+    try {
+        return JSON.parse(asLocatorWithFactory(new StepsFactory(), selector));
+    }
+    catch {
+        // Not a selector Playwright can turn into locators; keep it as a raw selector.
+        return [{ kind: 'default', base: 'page', body: selector }];
+    }
+}
+// Human-readable Playwright form, e.g. getByRole('button', { name: 'Sign in' }).
+export function describeSelector(selector) {
+    return asLocator('javascript', selector);
+}
+//# sourceMappingURL=locator.js.map

package/dist/naming.js

@@ -0,0 +1,31 @@
+// Splits "loginFlow", "login-flow", "Login flow" or "LoginFlowTest" into lowercase words.
+export function words(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map(word => word.toLowerCase());
+}
+function safeWords(name) {
+    const result = words(name);
+    if (!result.length)
+        return ['recorded'];
+    if (/^[0-9]/.test(result[0]))
+        result.unshift('test');
+    return result;
+}
+const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+export const pascalCase = (name) => safeWords(name).map(capitalize).join('');
+export const camelCase = (name) => safeWords(name).map((word, i) => i ? capitalize(word) : word).join('');
+export const snakeCase = (name) => safeWords(name).join('_');
+export const kebabCase = (name) => safeWords(name).join('-');
+// Recovers the test name from a file name: login_test.go, LoginTest.java, login.spec.js → "login".
+export function nameFromFileName(fileName) {
+    const base = fileName.replace(/^.*[\\/]/, '').replace(/\.[^.]+$/, '');
+    return base
+        .replace(/\.(spec|test)$/i, '')
+        .replace(/(_test|Test|Tests|IT)$/, '')
+        || 'recorded';
+}
+//# sourceMappingURL=naming.js.map

package/dist/record.js

@@ -0,0 +1,23 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+// Compiled: dist/recorder-process.js. From sources (tests), Node runs the .ts file directly.
+const recorderProcess = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './recorder-process.ts' : './recorder-process.js', import.meta.url));
+// Starts the Playwright recorder in a child process. It rewrites `outputFile` (JSONL) after every
+// recorded action and exits when the recorded browser is closed.
+// TESTGEN_RECORDER_HEADLESS=1 records in a headless browser (for tests).
+export function startCodegen(url, outputFile, options, stdio = 'inherit') {
+    const processOptions = {
+        ...options,
+        url,
+        outputFile,
+        headless: !!process.env.TESTGEN_RECORDER_HEADLESS,
+    };
+    return spawn(process.execPath, [recorderProcess, JSON.stringify(processOptions)], { stdio });
+}
+export function waitForExit(child) {
+    return new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', code => resolve(code ?? 0));
+    });
+}
+//# sourceMappingURL=record.js.map

package/dist/recorder-process.js

@@ -0,0 +1,102 @@
+// Runs Playwright's recorder (the engine behind `playwright codegen`) in its own process, with the
+// Playwright Inspector window hidden: the user only sees the browser being recorded, and the code
+// is shown by testgen. Mirrors codegen's own browser setup (packages/playwright-core/src/cli).
+//
+// Started by record.ts: node recorder-process.js '<RecorderProcessOptions as JSON>'
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import * as playwright from 'playwright-core';
+async function main(options) {
+    // Playwright's own hook for running the recorder's Inspector window headless.
+    if (!options.inspector)
+        process.env.PWTEST_CLI_HEADLESS = '1';
+    const browserType = { chromium: playwright.chromium, firefox: playwright.firefox, webkit: playwright.webkit }[options.browser ?? 'chromium'];
+    if (!browserType)
+        throw new Error(`Unknown browser "${options.browser}": use chromium, firefox or webkit.`);
+    const launchOptions = { headless: !!options.headless, handleSIGINT: false };
+    if (options.channel)
+        launchOptions.channel = options.channel;
+    let contextOptions = {};
+    if (options.device) {
+        const device = playwright.devices[options.device];
+        if (!device)
+            throw new Error(`Unknown device "${options.device}".`);
+        contextOptions = { ...device };
+    }
+    // Like codegen: a crisp headed browser, and no touch emulation on WebKit for Linux.
+    const headedScaleFactor = os.platform() === 'darwin' ? 2 : 1;
+    if (browserType.name() === 'webkit' && process.platform === 'linux') {
+        delete contextOptions.hasTouch;
+        delete contextOptions.isMobile;
+    }
+    if (options.viewportSize) {
+        const [width, height] = options.viewportSize.split(',').map(Number);
+        if (!width || !height)
+            throw new Error('Invalid viewport size: use "width,height", for example 1280,720.');
+        contextOptions.viewport = { width, height };
+    }
+    if (options.userAgent)
+        contextOptions.userAgent = options.userAgent;
+    if (options.lang)
+        contextOptions.locale = options.lang;
+    if (options.colorScheme)
+        contextOptions.colorScheme = options.colorScheme;
+    if (options.timezone)
+        contextOptions.timezoneId = options.timezone;
+    if (options.loadStorage)
+        contextOptions.storageState = options.loadStorage;
+    if (options.ignoreHttpsErrors)
+        contextOptions.ignoreHTTPSErrors = true;
+    const browser = await browserType.launch(launchOptions);
+    const context = await browser.newContext({ ...contextOptions, ...(options.headless ? {} : { deviceScaleFactor: headedScaleFactor }) });
+    let closing = false;
+    const close = async (code) => {
+        if (closing)
+            return;
+        closing = true;
+        if (options.saveStorage)
+            await context.storageState({ path: options.saveStorage }).catch(() => { });
+        // The recorder rewrites its output file on a 250ms throttle; let the last write land.
+        await new Promise(resolve => setTimeout(resolve, 500));
+        await browser.close().catch(() => { });
+        process.exit(code);
+    };
+    // Closing the last tab ends the recording, as with codegen.
+    context.on('page', page => page.on('close', () => {
+        if (!context.pages().length)
+            void close(0);
+    }));
+    browser.on('disconnected', () => void close(0));
+    for (const signal of ['SIGINT', 'SIGTERM'])
+        process.on(signal, () => void close(0));
+    context.setDefaultTimeout(0);
+    context.setDefaultNavigationTimeout(0);
+    await context._enableRecorder({
+        language: 'jsonl',
+        mode: 'recording',
+        outputFile: path.resolve(options.outputFile),
+        launchOptions: options.channel ? { channel: options.channel } : {},
+        contextOptions,
+        device: options.device,
+        saveStorage: options.saveStorage,
+        testIdAttributeName: options.testIdAttribute,
+        handleSIGINT: false,
+    });
+    const page = await context.newPage();
+    if (options.url)
+        await page.goto(normalizeUrl(options.url)).catch(error => console.error(`testgen: could not open ${options.url}: ${error.message}`));
+}
+// Same rules as codegen: local files become file:// URLs, bare hosts get http://.
+function normalizeUrl(url) {
+    if (fs.existsSync(url))
+        return 'file://' + path.resolve(url);
+    if (!/^(https?:|file:|about:|data:)/.test(url))
+        return 'http://' + url;
+    return url;
+}
+main(JSON.parse(process.argv[2] ?? '{}')).catch(error => {
+    console.error(`testgen: ${error.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=recorder-process.js.map

package/dist/recording.js

@@ -0,0 +1,82 @@
+const defaultHeader = { browserName: 'chromium', launchOptions: {}, contextOptions: {} };
+export function parseRecording(text, source = 'recording') {
+    let header;
+    const result = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        if (!lines[i].trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(lines[i]);
+        }
+        catch {
+            throw new Error(`${source}:${i + 1}: not valid JSON`);
+        }
+        if (!header && !result.length && typeof entry.browserName === 'string') {
+            header = { ...defaultHeader, ...entry };
+            continue;
+        }
+        if (typeof entry.name !== 'string')
+            throw new Error(`${source}:${i + 1}: expected a recorded action with a "name"`);
+        // `locator` is Playwright's own rendering of `selector`; generators re-parse the selector.
+        const { signals = [], pageGuid = 'page', locator, ...action } = entry;
+        result.push({ pageGuid, signals, action });
+    }
+    return { header: header ?? defaultHeader, actions: collapseActions(result) };
+}
+// Same rule as Playwright's recorder: consecutive fills of one field become a single fill.
+function collapseActions(list) {
+    const result = [];
+    for (const current of list) {
+        const last = result[result.length - 1];
+        const merge = last && current.action.name === 'fill' && last.action.name === 'fill'
+            && current.pageGuid === last.pageGuid && current.action.selector === last.action.selector;
+        if (merge)
+            result[result.length - 1] = { ...current, signals: [...last.signals, ...current.signals] };
+        else
+            result.push(current);
+    }
+    return result;
+}
+export function signalsOf(actionInContext) {
+    const find = (name) => actionInContext.signals.find(signal => signal.name === name);
+    return {
+        popup: find('popup'),
+        download: find('download'),
+        dialog: find('dialog'),
+        expect: find('expect'),
+    };
+}
+// Mirrors Playwright's codegen: the first page and every page opened later get stable names
+// ("page", "page1", ...), assigned in the order the recording mentions them.
+export class PageAliases {
+    _aliases = new Map();
+    alias(pageGuid) {
+        let alias = this._aliases.get(pageGuid);
+        if (!alias) {
+            alias = 'page' + (this._aliases.size || '');
+            this._aliases.set(pageGuid, alias);
+        }
+        return alias;
+    }
+}
+// Recorded modifier bit mask → Playwright modifier names (same mapping as Playwright's codegen).
+export function toKeyboardModifiers(modifiers) {
+    const result = [];
+    if (modifiers & 1)
+        result.push('Alt');
+    if (modifiers & 2 || modifiers & 4)
+        result.push('ControlOrMeta');
+    if (modifiers & 8)
+        result.push('Shift');
+    return result;
+}
+// "Shift+Enter" style shortcut for a recorded `press` action.
+export function shortcutOf(action) {
+    return [...toKeyboardModifiers(action.modifiers), action.key].join('+');
+}
+export function isBlankUrl(url) {
+    return !url || url === 'about:blank' || url === 'chrome://newtab/';
+}
+//# sourceMappingURL=recording.js.map