spp-lang 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Will Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,171 @@
-# Temporary Holding Version
+# 🥒 Spec++
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Specs that run. Written by agents, read by people.
+
+```gherkin
+Feature: Signing in
+
+  Scenario: The right password
+    Given I Visit "/"
+    When I Fill the Field "Email" with "will@example.com"
+    And I Fill the Field "Password" with "hunter2"
+    And I Click the Button "Sign in"
+    Then I should See the Heading "Welcome back"
+```
+
+Spec++ is Gherkin without step definitions. Capitalised words are code and lowercase words
+are prose, so a step runs as written. Every scenario runs as a Playwright test.
+
+## Why
+
+Agents writing tests reach for sleeps, conditionals and CSS selectors until a test passes.
+Spec++ doesn't have them. Steps find elements by role, label and visible text, as a user
+would, and a scenario does the same thing every run. A reviewer only has to ask whether the
+spec tests the right thing. When nothing else works, `TestId` finds an element by test id,
+and it stands out in review.
+
+## Getting started
+
+Spec++ needs Node.js 22.13 or later.
+
+```sh
+npm install --save-dev spp-lang @playwright/test
+npx playwright install chromium
+```
+
+```ts
+// playwright.config.ts
+import { defineConfig } from '@playwright/test'
+import { defineSppConfig } from 'spp-lang'
+
+export default defineConfig({
+  ...defineSppConfig({ features: ['features'] }),
+  use: { baseURL: 'http://localhost:3000' },
+})
+```
+
+```sh
+npx playwright test
+npx playwright test features/sign-in.spp:12   # the scenario on line 12
+```
+
+`defineSppConfig` generates a small test file per `.spp` file in `.spp-tests/`, which you
+should add to `.gitignore`. The rest of Playwright works as usual: projects, retries,
+sharding, UI mode, the trace viewer and
+[its VS Code extension](https://marketplace.visualstudio.com/items?itemName=ms-playwright.playwright).
+Failures point at the word in the `.spp` file that failed.
+
+Without a Playwright config, `npx spp-lang test --base-url http://localhost:3000` runs every
+`.spp` file under the current directory.
+
+## The language
+
+Capitalised words run right to left. In `Click the Button "Sign in"`, the text comes first,
+`Button` turns it into the button with that name, and `Click` clicks it. Lowercase words
+are skipped. Under the hood it's a small stack-based language, borrowed from
+[Cognate](https://cognate-lang.github.io/). The [reference](docs/reference.md) covers
+everything below in more detail, along with config options and multi-project setups.
+
+Finding things follows [Testing Library](https://testing-library.com/docs/queries/about):
+
+| Word | Finds |
+| --- | --- |
+| `Button`, `Heading`, `Link`, `Checkbox`, `Row`, `Dialog`… | an element by ARIA role and name |
+| `Field`, `Label` | a form control by its label |
+| `Text` | an element by its text |
+| `Placeholder`, `Alt`, `Title`, `TestId` | an element by that attribute |
+
+Names match exactly. `Containing "Kale"` matches part of a name, and `Within` searches
+inside another element.
+
+Actions: `Visit`, `Reload`, `Back`, `Click`, `Double-click`, `Hover`, `Focus`, `Check`,
+`Uncheck`, `Clear`, `Fill`, `Type`, `Select`, `Press`.
+
+Checks: `See`, `Visible`, `Hidden`, `Checked`, `Enabled`, `Disabled`, `Focused`, `Empty`,
+`Value`, `Read`, `Contain`, `At` and `Titled`. `Not` negates any of them, and they retry
+like Playwright's `expect`.
+
+```gherkin
+When I Click the Button "Remove" Within the Row Containing "Kale"
+Then I should Not See the Cell "Kale"
+And I should be At "/list"
+```
+
+Backgrounds, Scenario Outlines, Rules and data tables work as in Cucumber. Tags become
+Playwright tags, so `@skip`, `@only` and `--grep @smoke` work.
+
+### Your own words
+
+Project vocabulary is written in Spec++ too, with `Define`:
+
+```gherkin
+Define: Add Text (Item)
+  Fill the Field "Item" with Item
+  Click the Button "Add"
+
+Feature: The grocery list
+
+  Scenario: Adding things
+    When I Add "Milk" to the list
+    Then I should See the Cell "Milk"
+```
+
+After its name, a Define lists what it takes: `Text`, `Number`, `Element`, `Table` or
+`Any`, with an optional name in brackets. Defines can sit above a Feature or in a file of
+their own, and every file in the project can use them. A Define that leaves one value,
+like `Define: Cart` leaving a region of the page, becomes a type that other Defines can take.
+
+### Checking
+
+Every word has a type, so steps are checked before a browser starts. The types of your own
+Defines are inferred from how they're used.
+
+```
+SppError: Click expected something on the page, but got "Add"
+
+  > 4 |     When I Click "Add"
+      |            ^
+```
+
+```sh
+npx spp-lang check        # check without running
+npx spp-lang dictionary   # list every word you can use, with its type
+```
+
+## In Markdown
+
+` ```spp ` blocks in Markdown files run as tests too, like Rust's doctests, so the examples
+in your docs stay true. Mark a block ` ```spp ignore ` to leave it out. See
+[`examples/demo/features/README.md`](examples/demo/features/README.md).
+
+## Editors
+
+`spp-lang lsp` is a language server with diagnostics, hover, go to definition, find
+references and completion.
+
+- **VS Code:** install
+  [the Spec++ extension](https://marketplace.visualstudio.com/items?itemName=spp-lang.spp-vscode).
+  It uses your project's `spp-lang` if there is one.
+- **Claude Code:** install the plugin, which teaches Claude the language and runs the
+  language server.
+
+  ```sh
+  claude plugin marketplace add willmartian/spp-lang
+  claude plugin install spp-lang@spp-lang
+  ```
+
+- **Neovim** (0.11 or later):
+
+  ```lua
+  vim.filetype.add({ extension = { spp = 'spp' } })
+  vim.lsp.config('spp', {
+    cmd = { 'npx', 'spp-lang', 'lsp' },
+    filetypes = { 'spp' },
+    root_markers = { 'package.json', '.git' },
+  })
+  vim.lsp.enable('spp')
+  ```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).

package/dist/bin/spp-lang.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/spp-lang.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+// spp-lang test [paths...] [--base-url <url>] [playwright test options...]
+// spp-lang check [paths...]
+// spp-lang dictionary
+// spp-lang lsp
+//
+// Runs the scenarios with Playwright, or just checks them, without a browser,
+// or lists the words they can use. The project's Playwright config says where
+// the .spp files are; without one, every .spp file, and every Markdown file's
+// ```spp blocks, under the current directory. Everything else, like --headed,
+// --ui or --grep, goes to Playwright.
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { styleText } from 'node:util';
+import { Command, Option } from 'commander';
+import { browser } from '../src/backends/playwright/words.js';
+import { findConfig, loadProjects } from '../src/config.js';
+import { analyze, check, format } from '../src/language/check.js';
+import { core } from '../src/language/cognate.js';
+import { discover, LoadError, load } from '../src/language/load.js';
+import { dictionary } from '../src/tools/dictionary.js';
+import { leftovers } from '../src/words/shared.js';
+// Commander leaves the colour out when the output isn't a terminal, or $NO_COLOR is set.
+const style = (format, text) => styleText(format, text, { validateStream: false });
+// From the source, package.json is one directory up; once built, two.
+const packageJson = ['../package.json', '../../package.json']
+    .map((p) => path.join(import.meta.dirname, p))
+    .find((p) => fs.existsSync(p));
+if (!packageJson)
+    throw new Error(`No package.json above ${import.meta.dirname}`);
+const { version } = JSON.parse(fs.readFileSync(packageJson, 'utf8'));
+const program = new Command('spp-lang')
+    .usage('<command> [options]')
+    .version(version, '-V, --version', 'Show the version')
+    .helpOption('-h, --help', 'Show help')
+    .helpCommand('help [command]', 'Show help for a command')
+    // Set before the subcommands, which inherit it.
+    .configureHelp({
+    styleTitle: (s) => style('bold', s),
+    styleCommandText: (s) => style('cyan', s),
+    styleSubcommandText: (s) => style('cyan', s),
+    styleOptionText: (s) => style('cyan', s),
+})
+    .addHelpText('beforeAll', `${style(['green', 'bold'], 'Spec++')} ${style('dim', version)}\n`)
+    .addHelpText('before', 'Specs that run. Written by agents, read by people.\n')
+    .addHelpText('after', `
+${style('bold', 'Examples:')}
+  ${style('dim', '$')} spp-lang test features --base-url http://localhost:3000
+  ${style('dim', '$')} spp-lang test features/cart.spp:12 --headed
+  ${style('dim', '$')} spp-lang check
+
+The project is what the defineSppConfig calls in the Playwright config above
+the current directory say, or, without one, every .spp file, and Markdown file
+with a \`\`\`spp block, under it. Every Define in a project can be used by all
+of its files.`);
+program
+    .command('test')
+    .usage('[paths...] [--base-url <url>] [playwright test options...]')
+    .description('Run the scenarios as Playwright tests')
+    .argument('[paths...]')
+    .addOption(new Option('-u, --base-url <url>', 'Where "Visit "/"" goes').env('SPP_BASE_URL'))
+    .allowUnknownOption()
+    .addHelpText('after', `
+Runs "playwright test" with the project's Playwright config, or, without one,
+on every .spp file under the current directory. A path can be a directory, a
+file, or a file and a line, like features/cart.spp:12, for the scenario on that
+line, or the one a step on that line is in. The \`\`\`spp blocks in Markdown
+files are scenarios too, so README.md:40 works the same.
+
+Everything else, like --headed, --ui, --grep or --project, is passed to
+"playwright test" as it is.`)
+    .action((args, options) => process.exit(runTests(args, options.baseUrl)));
+program
+    .command('check')
+    .description('Check the files without a browser')
+    .argument('[paths...]')
+    .addHelpText('after', `
+Checks every file under each path, or the whole project, and exits non-zero if
+it finds a mistake. The rest of the project is still loaded, for its Defines.`)
+    .action(async (paths) => process.exit(checkOnly(await loadProjects(), paths)));
+program
+    .command('dictionary')
+    .description('List every word the project can use')
+    .addHelpText('after', `
+Lists the built-in words and the project's own Defines, with what each takes
+and leaves.`)
+    .action(async () => process.exit(printDictionary(await loadProjects())));
+program
+    .command('lsp')
+    .description('Language server for editors')
+    .addHelpText('after', `
+A language server over stdio: mistakes as you type, signatures on hover,
+completion and go to definition.`)
+    // What editors' language clients pass. Stdio is the only way it talks, and
+    // the server reads the client's process id itself, to exit when it does.
+    .addOption(new Option('--stdio').hideHelp())
+    .addOption(new Option('--clientProcessId <pid>').hideHelp())
+    .action(async () => {
+    // Loaded only here, so running tests doesn't pay for it.
+    const { startServer } = await import('../src/tools/lsp.js');
+    startServer();
+});
+await program.parseAsync();
+// Whether a file is one of those the paths name; with none, every file is.
+function named(paths, cwd) {
+    const targets = paths.map((p) => path.resolve(cwd, p.replace(/:\d+$/, '')));
+    return (file) => !targets.length || targets.some((t) => file === t || file.startsWith(t + path.sep));
+}
+// A project's files, and why those that don't load don't.
+function loadAll(project) {
+    const files = [];
+    const broken = [];
+    for (const file of discover(project.features, project.root, project.ignore)) {
+        try {
+            files.push(load(file));
+        }
+        catch (err) {
+            if (!(err instanceof LoadError))
+                throw err;
+            broken.push(err);
+        }
+    }
+    return { files, broken };
+}
+function checkOnly(projects, paths) {
+    const cwd = process.cwd();
+    const shown = named(paths, cwd);
+    // Each project is checked whole, since the named files may use Defines from
+    // the rest of it. A file in more than one is reported once.
+    const seen = new Set();
+    const checked = new Set();
+    let problems = 0;
+    for (const project of projects) {
+        const { files, broken } = loadAll(project);
+        for (const err of broken) {
+            if (!shown(err.file) || seen.has(err.file))
+                continue;
+            seen.add(err.file);
+            checked.add(err.file);
+            // A file that doesn't parse: its message already says where.
+            console.log(`${path.relative(cwd, err.file)}\n  ${err.message}\n`);
+            problems++;
+        }
+        const report = check(files, { words: browser(core()), settle: leftovers, cwd });
+        // An Outline's rows share their steps, and so their mistakes.
+        const diagnostics = [...report.vocabulary, ...report.scenarios.values()].filter((d) => {
+            const key = `${d.file}:${d.line}:${d.column}:${d.message}`;
+            return shown(d.file) && !seen.has(key) && seen.add(key);
+        });
+        for (const d of diagnostics)
+            console.log(`${format(d, fs.readFileSync(d.file, 'utf8'), cwd)}\n`);
+        problems += diagnostics.length;
+        for (const f of files)
+            if (shown(f.file))
+                checked.add(f.file);
+    }
+    const count = checked.size;
+    const files = `${count} file${count === 1 ? '' : 's'}`;
+    console.log(problems ? `${problems} mistake${problems === 1 ? '' : 's'} in ${files}` : `No mistakes in ${files}`);
+    return problems ? 1 : 0;
+}
+function printDictionary(projects) {
+    const cwd = process.cwd();
+    const words = browser(core());
+    for (const [i, project] of projects.entries()) {
+        // With more than one project, each has words of its own.
+        if (projects.length > 1) {
+            const where = project.features.map((f) => path.relative(cwd, f) || '.').join(', ');
+            console.log(`${i ? '\n' : ''}${style('bold', `Project: ${where}`)}\n`);
+        }
+        // A file that doesn't parse has no Defines to list; check says why.
+        const { files } = loadAll(project);
+        console.log(dictionary(words, analyze(files, { words, settle: leftovers, cwd }), cwd));
+    }
+    return 0;
+}
+// Runs Playwright with the project's config, or Spec++'s own without one.
+// Every argument goes to Playwright, but a .spp or Markdown file and a step's
+// line becomes its scenario's line, which is what Playwright knows the test by.
+function runTests(args, baseURL) {
+    const require = createRequire(import.meta.url);
+    // .ts when run from source, .js once built
+    const config = findConfig(process.cwd()) ??
+        path.join(import.meta.dirname, `../src/backends/playwright/runner/playwright.config${path.extname(import.meta.filename)}`);
+    const result = spawnSync(process.execPath, [require.resolve('@playwright/test/cli'), 'test', '--config', config, ...args.map(scenarioLine)], {
+        stdio: 'inherit',
+        env: { ...process.env, SPP_CWD: process.cwd(), ...(baseURL ? { SPP_BASE_URL: baseURL } : {}) },
+    });
+    return result.status ?? 1;
+}
+// "features/cart.spp:14", where line 14 is a step, as "features/cart.spp:12",
+// the line of its scenario. Anything else is left as it is.
+function scenarioLine(arg) {
+    const m = /^(.+\.(?:spp|md)):(\d+)$/.exec(arg);
+    if (!m || !fs.existsSync(m[1]))
+        return arg;
+    const [, file, line] = m;
+    let loaded;
+    try {
+        loaded = load(path.resolve(file));
+    }
+    catch {
+        return arg;
+    }
+    const n = Number(line);
+    const scenario = loaded.features.flatMap((f) => f.scenarios).find((s) => s.lines.includes(n));
+    if (!scenario)
+        return arg;
+    // A step of an Outline is in every row, so it names the Outline, and all of them.
+    const target = scenario.outline && n !== scenario.line ? scenario.outline.line : scenario.line;
+    return target === n ? arg : `${file}:${target}`;
+}

package/dist/src/backends/playwright/generate.d.ts

@@ -0,0 +1,13 @@
+import type { Project } from '../../config.ts';
+export interface SppConfig {
+    features?: string[];
+    ignore?: string[];
+    outputDir?: string;
+    root?: string;
+}
+export interface SppTests {
+    testDir: string;
+    testMatch: RegExp;
+}
+export declare function defineSppConfig(config?: SppConfig): SppTests;
+export declare function generate(project: Project): string[];

package/dist/src/backends/playwright/generate.js

@@ -0,0 +1,238 @@
+// Spec++ in a Playwright config: scenarios become ordinary Playwright tests,
+// so Playwright's command line, UI mode, reports and editor extensions work on
+// them as they do on any test.
+//
+//     // playwright.config.ts
+//     import { defineConfig } from '@playwright/test'
+//     import { defineSppConfig } from 'spp-lang'
+//
+//     export default defineConfig({
+//       ...defineSppConfig({ features: ['features'] }),
+//       use: { baseURL: 'http://localhost:3000' },
+//     })
+//
+// defineSppConfig writes a test file for each .spp file, and each Markdown
+// file with an ```spp block, into its outputDir, and returns the testDir and
+// testMatch that find them. The testDir is the project's root, not the
+// outputDir, so Playwright says where tests are relative to the root:
+// features/cart.spp, not ../features/cart.spp.
+//
+// The files are written every time Playwright loads the config, so they're
+// never out of date, and they're no more than a list of the scenarios: what
+// each one does is read from the .spp file when it runs (runtime.ts). Each has
+// a source map back to its .spp file, so Playwright puts every test, and every
+// failure, on its line in the .spp file.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { registry } from '../../config.js';
+import { check } from '../../language/check.js';
+import { core } from '../../language/cognate.js';
+import { discover, LoadError, load } from '../../language/load.js';
+import { escapeRegExp, leftovers } from '../../words/shared.js';
+import { browser } from './words.js';
+export function defineSppConfig(config = {}) {
+    const root = path.resolve(config.root ?? callerDir());
+    const strings = (paths, what) => {
+        if (paths !== undefined && !(Array.isArray(paths) && paths.every((p) => typeof p === 'string'))) {
+            throw new Error(`defineSppConfig: ${what} should be a list of paths`);
+        }
+        return (paths ?? []).map((p) => path.resolve(root, p));
+    };
+    const features = strings(config.features, 'features');
+    const project = {
+        root,
+        features: features.length ? features : [root],
+        ignore: strings(config.ignore, 'ignore'),
+        outputDir: path.resolve(root, config.outputDir ?? '.spp-tests'),
+    };
+    registry.projects.push(project);
+    // Playwright loads the config in every worker too, but only its first load,
+    // in the main process, should write anything.
+    if (!registry.collecting && process.env.TEST_WORKER_INDEX === undefined)
+        generate(project);
+    return { testDir: root, testMatch: new RegExp(`^${escapeRegExp(project.outputDir + path.sep)}.*\\.spec\\.js$`) };
+}
+// The directory of the file that called defineSppConfig: the config. Read
+// from the stack, as Playwright reads where each test is declared.
+function callerDir() {
+    const prepare = Error.prepareStackTrace;
+    let caller;
+    try {
+        Error.prepareStackTrace = (_err, frames) => {
+            caller = frames[0]?.getFileName();
+            return '';
+        };
+        const holder = {};
+        Error.captureStackTrace(holder, defineSppConfig);
+        // Reading the stack is what runs prepareStackTrace.
+        if (holder.stack === undefined)
+            caller = undefined;
+    }
+    finally {
+        Error.prepareStackTrace = prepare;
+    }
+    if (!caller)
+        throw new Error("defineSppConfig couldn't tell which file called it. Give it a root.");
+    return path.dirname(caller.startsWith('file:') ? fileURLToPath(caller) : caller);
+}
+// ---------------------------------------------------------------- generating
+const HEADER = '// Generated by Spec++';
+// .ts when run from source, .js once built.
+const RUNTIME = path.join(import.meta.dirname, `runtime${path.extname(import.meta.filename)}`);
+// Writes a test file for each file in the project that has scenarios or
+// mistakes, and removes those for files that no longer do. A file is only
+// written when it changes, so watchers don't see a change on every run.
+export function generate(project) {
+    const files = [];
+    const broken = new Map();
+    for (const file of discover(project.features, project.root, project.ignore)) {
+        try {
+            files.push(load(file));
+        }
+        catch (err) {
+            if (!(err instanceof LoadError))
+                throw err;
+            broken.set(file, err);
+        }
+    }
+    const report = check(files, { words: browser(core()), settle: leftovers, cwd: project.root });
+    const written = new Set();
+    const write = (source, test) => {
+        const out = path.join(project.outputDir, `${path.relative(project.root, source)}.spec.js`);
+        fs.mkdirSync(path.dirname(out), { recursive: true });
+        const { code, map } = render(project, source, out, test);
+        for (const [file, text] of [
+            [out, code],
+            [`${out}.map`, map],
+        ]) {
+            if (!fs.existsSync(file) || fs.readFileSync(file, 'utf8') !== text)
+                fs.writeFileSync(file, text);
+            written.add(file);
+        }
+    };
+    for (const { file, features } of files) {
+        const defines = report.vocabulary.filter((d) => d.file === file);
+        const mistakes = new Set(features.flatMap((f) => f.scenarios).filter((s) => report.scenarios.has(s)));
+        if (features.some((f) => f.scenarios.length) || defines.length)
+            write(file, { features, defines, mistakes });
+    }
+    for (const [file, err] of broken)
+        write(file, { features: [], defines: [], broken: err });
+    // ESM whatever the project's own package.json says.
+    const pkg = path.join(project.outputDir, 'package.json');
+    fs.mkdirSync(project.outputDir, { recursive: true });
+    if (!fs.existsSync(pkg))
+        fs.writeFileSync(pkg, '{ "type": "module" }\n');
+    removeStale(project.outputDir, written);
+    return [...written];
+}
+// The file, and its source map, which is a file of its own: Playwright reads
+// either kind, but its VS Code extension only reads a map in a file, and needs
+// one to know that the tests are the .spp file's.
+function render(project, source, out, { features, defines, mistakes, broken }) {
+    const s = (value) => JSON.stringify(value);
+    const lines = [
+        [
+            `${HEADER} from ${path.relative(project.root, source)}, each time Playwright loads its config. Don't edit it.`,
+            undefined,
+        ],
+        [`import { project } from ${s(pathToFileURL(RUNTIME).href)}`, undefined],
+        [`const { test, scenario, mistake, define, broken } = project(${s(project)})`, undefined],
+        [`const file = ${s(source)}`, undefined],
+    ];
+    if (broken) {
+        lines.push([`test(${s(path.basename(source))}, broken(file))`, broken.problems[0]?.line ?? 1]);
+    }
+    // One test per broken Define, as there's one per scenario.
+    const seen = new Set();
+    for (const d of defines) {
+        if (seen.has(d.line))
+            continue;
+        seen.add(d.line);
+        lines.push([`test(${s(d.define ? `Define ${d.define}` : 'Defines')}, define(file, ${d.line}))`, d.line]);
+    }
+    for (const feature of features) {
+        if (!feature.scenarios.length)
+            continue;
+        lines.push([`test.describe(${s(feature.name || path.basename(source))}, () => {`, feature.line]);
+        // An Outline's rows go together, under it. open is the line of the
+        // Outline whose describe is open.
+        let open;
+        for (const scenario of feature.scenarios) {
+            const { outline } = scenario;
+            if (open !== undefined && outline?.line !== open) {
+                lines.push(['  })', undefined]);
+                open = undefined;
+            }
+            if (outline && open === undefined) {
+                lines.push([`  test.describe(${s(outline.name)}, () => {`, outline.line]);
+                open = outline.line;
+            }
+            const indent = outline ? '    ' : '  ';
+            lines.push([`${indent}${declaration(scenario, mistakes?.has(scenario) ?? false)}`, scenario.line]);
+        }
+        if (open !== undefined)
+            lines.push(['  })', undefined]);
+        lines.push(['})', undefined]);
+    }
+    const code = `${lines.map(([line]) => line).join('\n')}\n//# sourceMappingURL=${path.basename(out)}.map\n`;
+    return { code, map: sourceMap(path.relative(path.dirname(out), source), lines) };
+}
+function declaration(scenario, mistaken) {
+    const s = (value) => JSON.stringify(value);
+    const title = scenario.outline ? scenario.outline.row : scenario.name;
+    const declare = scenario.tags.includes('@only') ? 'test.only' : 'test';
+    const details = scenario.tags.length ? `{ tag: ${s(scenario.tags)} }, ` : '';
+    const body = mistaken ? 'mistake' : 'scenario';
+    return `${declare}(${s(title)}, ${details}${body}(file, ${scenario.line}))`;
+}
+function removeStale(dir, keep) {
+    if (!fs.existsSync(dir))
+        return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            removeStale(full, keep);
+            if (!fs.readdirSync(full).length)
+                fs.rmdirSync(full);
+        }
+        else if (entry.name.endsWith('.spec.js') && !keep.has(full) && isGenerated(full)) {
+            fs.rmSync(full);
+            fs.rmSync(`${full}.map`, { force: true });
+        }
+    }
+}
+// Only files Spec++ wrote are removed, whatever else is there.
+const isGenerated = (file) => fs.readFileSync(file, 'utf8').startsWith(HEADER);
+// ---------------------------------------------------------------- source maps
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// A number as a source map writes it: base64 digits of five bits each, least
+// significant first, with the sign in the lowest bit of the first.
+function vlq(n) {
+    let rest = n < 0 ? (-n << 1) | 1 : n << 1;
+    let out = '';
+    do {
+        let digit = rest & 31;
+        rest >>>= 5;
+        if (rest)
+            digit |= 32;
+        out += BASE64[digit];
+    } while (rest);
+    return out;
+}
+// A version 3 source map, from each generated line that stands for
+// a line of the source to the start of that line. Each mapped line has one
+// segment: generated column 0, the only source, its line, column 0, each but
+// the generated column relative to the segment before.
+function sourceMap(source, lines) {
+    let previous = 0;
+    const mappings = lines.map(([, line]) => {
+        if (line === undefined)
+            return '';
+        const segment = `A${vlq(0)}${vlq(line - 1 - previous)}${vlq(0)}`;
+        previous = line - 1;
+        return segment;
+    });
+    return `${JSON.stringify({ version: 3, sources: [source], names: [], mappings: mappings.join(';') })}\n`;
+}

package/dist/src/backends/playwright/runner/playwright.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@playwright/test").PlaywrightTestConfig<{}, {}>;
+export default _default;