@sdods/core 0.12.0 → 0.13.0

package/dist/auth/capture.js

@@ -7,6 +7,7 @@ import { Logger } from '../logger.js';
 import { CompositeDataProvider } from '../data/provider.js';
 import { AuthStateCache } from '../fixtures/auth.js';
 import { defineAuth } from './index.js';
+import { toolCommand } from '../workspace-bin.js';
 const log = new Logger('auth');
 /** Users of a role from the pool dataset (capped by env.users.poolSize), without leasing them. */
 export async function poolUsers(config, role) {
@@ -80,7 +81,8 @@ async function defaultLaunch(name, headed) {
     return pw[name].launch({ headless: !headed });
 }
 async function defaultInteractive(args) {
-    const res = await execa('npx', args, { stdio: 'inherit', reject: false });
+    const [file, ...argv] = toolCommand(process.cwd(), args);
+    const res = await execa(file, argv, { stdio: 'inherit', reject: false });
     return res.exitCode ?? 1;
 }
 /**
@@ -137,7 +139,7 @@ export async function captureAuth(opts) {
                 log.step(`interactive login for ${user.username} (${user.role}) → complete the login, then close the window`);
                 const code = await (opts.runInteractive ?? defaultInteractive)(args);
                 if (code !== 0 && !existsSync(file)) {
-                    result.skipped = `codegen exited with ${code} and wrote no storage state`;
+                    result.skipped = `the login window closed with code ${code} before a session was saved`;
                 }
                 else if (existsSync(file)) {
                     cache.save(user, JSON.parse(readFileSync(file, 'utf8')));

package/dist/config/runner.d.ts

@@ -22,6 +22,8 @@ export interface SdodsUseOption {
     browser?: BrowserName;
 }
 export declare const DASHBOARD_REPORTER = "@sdods/core/reporters/dashboard";
+/** The console output of a run: scenario names and `sdods` follow-ups, not spec paths. */
+export declare const TERMINAL_REPORTER = "@sdods/core/reporters/terminal";
 /** Convenience for `sdods.runner.config.ts`: read the selection from SDODS_* env vars. */
 export declare function selectionFromEnv(env?: NodeJS.ProcessEnv): RunnerSelection;
 export interface GeneratedProject {

package/dist/config/runner.js

@@ -48,6 +48,8 @@ function browserUse(browser, projectChannel) {
     return { ...devices[DEVICE_FOR_BROWSER[browser]], ...(channel ? { channel } : {}) };
 }
 export const DASHBOARD_REPORTER = '@sdods/core/reporters/dashboard';
+/** The console output of a run: scenario names and `sdods` follow-ups, not spec paths. */
+export const TERMINAL_REPORTER = '@sdods/core/reporters/terminal';
 /** Convenience for `sdods.runner.config.ts`: read the selection from SDODS_* env vars. */
 export function selectionFromEnv(env = process.env) {
     const list = (v) => v
@@ -268,7 +270,13 @@ export function buildRunnerConfig(registry, sel = {}) {
         return [name];
     });
     {
-        reporter.push(reporterMode === 'server' ? ['line'] : reporterMode === 'quiet' ? ['dot'] : ['list']);
+        reporter.push([
+            TERMINAL_REPORTER,
+            {
+                mode: reporterMode === 'server' ? 'line' : reporterMode === 'quiet' ? 'dot' : 'list',
+                rootDir: first?.runtime.repoRoot ?? process.cwd(),
+            },
+        ]);
         reporter.push(['html', { outputFolder: join(runDir, runFiles.htmlReport), open: 'never' }]);
         // The cucumber reporter throws when no defineBddConfig() ran (recorded-only selections).
         if (bddConfigs > 0)

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './errors.js';
 export * from './logger.js';
+export * from './workspace-bin.js';
 export * from './config/index.js';
 export * from './api/index.js';
 export * from './auth/index.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from './errors.js';
 export * from './logger.js';
+export * from './workspace-bin.js';
 export * from './config/index.js';
 export * from './api/index.js';
 export * from './auth/index.js';

package/dist/lint/index.js

@@ -8,6 +8,7 @@ import { parseFeatureFile, scenariosOf } from './gherkin.js';
 import { projectRequirements } from '../analyze/traceability.js';
 import { checkStepAmbiguity } from './steps.js';
 import { ROLES_MATRIX_FILE, planMatrixExpansion } from '../matrix/index.js';
+import { toolCommand } from '../workspace-bin.js';
 export * from './gherkin.js';
 export function listFeatureFiles(root) {
     const out = [];
@@ -332,7 +333,12 @@ export async function detectUndefinedSteps(project, repoRoot) {
         SDODS_LINT: '1',
         SDODS_ARTIFACTS_DIR: join(repoRoot, '.sdods', 'lint'),
     };
-    const result = await execa('npx', ['bddgen', '-c', join(repoRoot, 'sdods.runner.config.ts')], {
+    const [file, ...argv] = toolCommand(repoRoot, [
+        'bddgen',
+        '-c',
+        join(repoRoot, 'sdods.runner.config.ts'),
+    ]);
+    const result = await execa(file, argv, {
         cwd: repoRoot,
         env,
         reject: false,
@@ -350,7 +356,7 @@ export async function detectUndefinedSteps(project, repoRoot) {
         if (m) {
             const stepLine = lines[i + 1]?.trim() ?? '';
             out.push({
-                message: `Undefined step: ${stepLine || '(see bddgen output)'}`,
+                message: `Undefined step: ${stepLine || '(see the generator output)'}`,
                 file: relative(project.root, m[1]).replace(/\\/g, '/'),
                 line: Number(m[2]),
             });
@@ -390,7 +396,7 @@ export async function detectUndefinedSteps(project, repoRoot) {
             .join(' | ');
         out.push({
             rule: 'steps/bddgen',
-            message: `bddgen failed to generate specs (exit ${result.exitCode}): ${tail || '(no output)'}`,
+            message: `Could not generate specs from the features (exit ${result.exitCode}): ${tail || '(no output)'}`,
         });
     }
     return out;

package/dist/recorder/codegen.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { execa } from 'execa';
 import { SdodsError } from '../errors.js';
 import { harPath, safeHarName } from '../har/paths.js';
+import { toolCommand } from '../workspace-bin.js';
 export function recordedDir(config) {
     return join(config.project.root, 'recorded');
 }
@@ -64,7 +65,8 @@ export async function runCodegen(opts) {
     mkdirSync(recordedDir(opts.config), { recursive: true });
     if (harFile)
         mkdirSync(join(harFile, '..'), { recursive: true });
-    const res = await execa('npx', args, {
+    const [file, ...argv] = toolCommand(opts.config.runtime.repoRoot, args);
+    const res = await execa(file, argv, {
         cwd: opts.config.runtime.repoRoot,
         stdio: 'inherit',
         reject: false,
@@ -73,7 +75,7 @@ export async function runCodegen(opts) {
     const exitCode = res.exitCode ?? 1;
     const produced = existsSync(outputFile);
     if (exitCode !== 0 && !produced) {
-        throw new SdodsError('RUN_FAILED', `playwright codegen exited with code ${exitCode} and produced no spec.`, {
+        throw new SdodsError('RUN_FAILED', `The recorder closed with code ${exitCode} before saving a spec.`, {
             hint: 'Codegen needs a display. On a headless machine, record on your workstation or import an existing spec into recorded/.',
             exitCode: 1,
         });

package/dist/reporters/index.d.ts

@@ -1,3 +1,4 @@
 export { default as DashboardReporter, type DashboardOptions } from './dashboard.js';
-export { DASHBOARD_REPORTER } from '../config/runner.js';
+export { default as TerminalReporter, type TerminalMode, type TerminalOptions, } from './terminal.js';
+export { DASHBOARD_REPORTER, TERMINAL_REPORTER } from '../config/runner.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/reporters/index.js

@@ -1,3 +1,4 @@
 export { default as DashboardReporter } from './dashboard.js';
-export { DASHBOARD_REPORTER } from '../config/runner.js';
+export { default as TerminalReporter, } from './terminal.js';
+export { DASHBOARD_REPORTER, TERMINAL_REPORTER } from '../config/runner.js';
 //# sourceMappingURL=index.js.map

package/dist/reporters/terminal.d.ts

@@ -0,0 +1,55 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestError, TestResult } from '@playwright/test/reporter';
+export type TerminalMode = 'list' | 'line' | 'dot';
+export interface TerminalOptions {
+    /** `list` (default, a line per scenario), `line` (the same, for logs and the server), `dot`. */
+    mode?: TerminalMode;
+    /** Where paths are shown relative to. Defaults to the working directory. */
+    rootDir?: string;
+    /** Output sink; tests inject one. Defaults to process.stdout. */
+    write?: (text: string) => void;
+    /** List the scenarios instead of reporting a run (`sdods run --list`; SDODS_LIST_ONLY=1). */
+    listOnly?: boolean;
+}
+/**
+ * The console output of `sdods run`, in SDODS terms.
+ *
+ * Replaces the runner's list/line/dot reporters, which print generated spec paths
+ * (`.sdods/generated/<run>/…/x.feature.spec.js`) as test names and end failures with
+ * `npx playwright show-trace`. Here a scenario is named by its feature and scenario title, the
+ * layer and browser come from the SDODS run-target name, and every follow-up is an `sdods` command.
+ *
+ * `[n/total]` stays on every scenario line: MCP `run_tests` reads progress from it.
+ */
+export default class TerminalReporter implements Reporter {
+    private readonly mode;
+    private readonly rootDir;
+    private readonly write;
+    private total;
+    private done;
+    private dots;
+    private readonly failures;
+    private readonly flaky;
+    private readonly counts;
+    private readonly errors;
+    constructor(options?: TerminalOptions);
+    private readonly listOnly;
+    /** This reporter owns the console, so the runner adds no reporter of its own. */
+    printsToStdio(): boolean;
+    onBegin(config: FullConfig, suite: Suite): void;
+    onStdOut(chunk: string | Buffer, test?: TestCase): void;
+    onStdErr(chunk: string | Buffer, test?: TestCase): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onError(error: TestError): void;
+    onEnd(result: FullResult): void;
+    private describeFailure;
+}
+/** Feature › Scenario, without the runner's project and generated-file segments. */
+export declare function title(test: TestCase): string;
+/** `[api]`, `[ui · chromium]` — from the SDODS run-target name, not the raw project name. */
+export declare function target(test: TestCase): string;
+/**
+ * `<project>: features/<dir>/x.feature` for a scenario generated from Gherkin, read back from the
+ * generated spec path `.sdods/generated/<run>/<project>/<layer>/<dir>/x.feature.spec.js`.
+ */
+export declare function featureOf(test: TestCase): string | undefined;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/reporters/terminal.js

@@ -0,0 +1,232 @@
+import { relative } from 'node:path';
+import pc from 'picocolors';
+import { parseRunnerProjectName } from '@sdods/contracts';
+/**
+ * The console output of `sdods run`, in SDODS terms.
+ *
+ * Replaces the runner's list/line/dot reporters, which print generated spec paths
+ * (`.sdods/generated/<run>/…/x.feature.spec.js`) as test names and end failures with
+ * `npx playwright show-trace`. Here a scenario is named by its feature and scenario title, the
+ * layer and browser come from the SDODS run-target name, and every follow-up is an `sdods` command.
+ *
+ * `[n/total]` stays on every scenario line: MCP `run_tests` reads progress from it.
+ */
+export default class TerminalReporter {
+    mode;
+    rootDir;
+    write;
+    total = 0;
+    done = 0;
+    dots = 0;
+    failures = [];
+    flaky = [];
+    counts = { passed: 0, failed: 0, skipped: 0, flaky: 0 };
+    errors = [];
+    constructor(options = {}) {
+        this.mode = options.mode ?? 'list';
+        this.rootDir = options.rootDir ?? process.cwd();
+        this.write = options.write ?? ((text) => process.stdout.write(text));
+        this.listOnly = options.listOnly ?? process.env.SDODS_LIST_ONLY === '1';
+    }
+    listOnly;
+    /** This reporter owns the console, so the runner adds no reporter of its own. */
+    printsToStdio() {
+        return true;
+    }
+    onBegin(config, suite) {
+        this.total = suite.allTests().length;
+        if (this.listOnly) {
+            const features = new Set();
+            for (const t of suite.allTests()) {
+                features.add(featureOf(t) ?? t.location.file);
+                this.write(`  ${title(t)} ${pc.dim(target(t))}\n`);
+            }
+            this.write(`\n${this.total} scenario${this.total === 1 ? '' : 's'} in ${features.size} file${features.size === 1 ? '' : 's'}\n`);
+            return;
+        }
+        const workers = config.workers;
+        this.write(pc.dim(`Running ${this.total} scenario${this.total === 1 ? '' : 's'} with ${workers} worker${workers === 1 ? '' : 's'}\n`));
+        if (this.mode !== 'dot')
+            this.write('\n');
+    }
+    onStdOut(chunk, test) {
+        if (this.mode === 'dot')
+            return;
+        this.write(test ? pc.dim(String(chunk)) : String(chunk));
+    }
+    onStdErr(chunk, test) {
+        if (this.mode === 'dot')
+            return;
+        process.stderr.write(test ? pc.dim(String(chunk)) : String(chunk));
+    }
+    onTestEnd(test, result) {
+        if (this.listOnly)
+            return;
+        const final = result.status === 'passed' ||
+            result.status === 'skipped' ||
+            result.status === 'interrupted' ||
+            result.retry >= test.retries;
+        if (!final) {
+            if (this.mode !== 'dot')
+                this.write(`       ${pc.yellow('↻')} ${title(test)} ${pc.dim(`${target(test)} · retry ${result.retry + 1} of ${test.retries}`)}\n`);
+            return;
+        }
+        this.done++;
+        const flaky = result.status === 'passed' && result.retry > 0;
+        let mark;
+        let dot;
+        if (flaky) {
+            this.counts.flaky++;
+            this.flaky.push(test);
+            mark = pc.yellow('±');
+            dot = pc.yellow('±');
+        }
+        else if (result.status === 'passed') {
+            this.counts.passed++;
+            mark = pc.green('✔');
+            dot = pc.green('·');
+        }
+        else if (result.status === 'skipped') {
+            this.counts.skipped++;
+            mark = pc.dim('↷');
+            dot = pc.dim('°');
+        }
+        else {
+            this.counts.failed++;
+            this.failures.push({ test, result });
+            mark = pc.red('✖');
+            dot = pc.red('F');
+        }
+        if (this.mode === 'dot') {
+            this.write(dot);
+            if (++this.dots % 80 === 0)
+                this.write('\n');
+            return;
+        }
+        const progress = pc.dim(`[${this.done}/${this.total}]`);
+        const time = pc.dim(`(${seconds(result.duration)})`);
+        const status = result.status === 'timedOut'
+            ? pc.red(' timed out')
+            : result.status === 'interrupted'
+                ? pc.yellow(' interrupted')
+                : '';
+        this.write(`${progress} ${mark} ${title(test)} ${pc.dim(target(test))}${status} ${time}\n`);
+    }
+    onError(error) {
+        this.errors.push(error);
+        this.write(`\n${pc.red('✖ Error outside a scenario')}\n${indent(formatError(error, this.rootDir), 2)}\n`);
+    }
+    onEnd(result) {
+        if (this.listOnly)
+            return;
+        if (this.mode === 'dot' && this.dots % 80 !== 0)
+            this.write('\n');
+        if (this.failures.length) {
+            this.write(`\n${pc.bold(pc.red(`Failed (${this.failures.length})`))}\n`);
+            this.failures.forEach((f, i) => this.write(this.describeFailure(f, i + 1)));
+        }
+        if (this.flaky.length) {
+            this.write(`\n${pc.bold(pc.yellow(`Flaky: passed on a retry (${this.flaky.length})`))}\n`);
+            for (const t of this.flaky)
+                this.write(`  ${title(t)} ${pc.dim(target(t))}\n`);
+        }
+        const parts = [
+            pc.green(`${this.counts.passed} passed`),
+            this.counts.failed ? pc.red(`${this.counts.failed} failed`) : '',
+            this.counts.flaky ? pc.yellow(`${this.counts.flaky} flaky`) : '',
+            this.counts.skipped ? pc.dim(`${this.counts.skipped} skipped`) : '',
+            // Never started: a setup scenario they depend on failed, --max-failures stopped the run, or
+            // it was interrupted. They have no result, so they would otherwise vanish from the count.
+            this.total > this.done ? pc.yellow(`${this.total - this.done} did not run`) : '',
+        ].filter(Boolean);
+        this.write(`\n  ${parts.join(', ')} ${pc.dim(`(${seconds(result.duration)})`)}\n`);
+    }
+    describeFailure({ test, result }, n) {
+        const lines = [];
+        const where = test.location ? relative(this.rootDir, test.location.file) : '';
+        lines.push(`\n  ${pc.red(`${n})`)} ${pc.bold(title(test))} ${pc.dim(target(test))}`);
+        const feature = featureOf(test);
+        if (feature || where)
+            lines.push(pc.dim(`     ${feature ?? `${where}:${test.location.line}`}`));
+        const errors = result.errors.length ? result.errors : result.error ? [result.error] : [];
+        // A generated spec is SDODS's translation of the feature, not code anyone wrote: its snippet
+        // and line point at the wrong file, and the feature path above is the one to open.
+        const generated = feature !== undefined;
+        for (const e of errors)
+            lines.push('', indent(formatError(e, this.rootDir, generated), 5));
+        const files = result.attachments.filter((a) => a.path);
+        const shots = files.filter((a) => a.contentType.startsWith('image/'));
+        // The before/after shots are in the dashboard; the console names the one at the failure.
+        const shot = shots.find((a) => /failure|failed/i.test(a.path)) ?? shots[shots.length - 1];
+        const video = files.find((a) => a.name === 'video');
+        const trace = files.find((a) => a.name === 'trace');
+        if (shot || video || trace)
+            lines.push('');
+        if (shot)
+            lines.push(`     ${pc.dim('screenshot')} ${relative(this.rootDir, shot.path)}`);
+        if (video)
+            lines.push(`     ${pc.dim('video     ')} ${relative(this.rootDir, video.path)}`);
+        if (trace)
+            lines.push(`     ${pc.dim('trace     ')} ${pc.cyan(`sdods trace ${quote(relative(this.rootDir, trace.path))}`)}`);
+        return lines.join('\n') + '\n';
+    }
+}
+/** Feature › Scenario, without the runner's project and generated-file segments. */
+export function title(test) {
+    // titlePath(): ['', <run target>, <spec file>, ...describe blocks, <test title>]
+    const path = test.titlePath().slice(3).filter(Boolean);
+    return (path.length ? path : [test.title]).join(' › ');
+}
+/** `[api]`, `[ui · chromium]` — from the SDODS run-target name, not the raw project name. */
+export function target(test) {
+    const name = test.parent?.project()?.name ?? '';
+    if (!name)
+        return '';
+    const parts = parseRunnerProjectName(name);
+    if (!parts)
+        return `[${name}]`;
+    const bits = [
+        parts.layer,
+        parts.layer === 'api' ? undefined : parts.browser,
+        parts.phase, // `setup`: the gate tier other scenarios depend on
+    ].filter(Boolean);
+    return `[${bits.join(' · ')}]`;
+}
+/**
+ * `<project>: features/<dir>/x.feature` for a scenario generated from Gherkin, read back from the
+ * generated spec path `.sdods/generated/<run>/<project>/<layer>/<dir>/x.feature.spec.js`.
+ */
+export function featureOf(test) {
+    const file = (test.location?.file ?? '').replace(/\\/g, '/');
+    const m = /\.sdods\/generated\/[^/]+\/([^/]+)\/[^/]+\/(.+\.feature)\.spec\.[cm]?js$/.exec(file);
+    return m ? `${m[1]}: features/${m[2]}` : undefined;
+}
+function formatError(error, rootDir, generated = false) {
+    const out = [];
+    let message = (error.message ?? error.value ?? 'Unknown error').trimEnd();
+    // The launch log (every browser flag, display warnings) follows "Browser logs:" and is in the
+    // trace; in the console it buries the one line that says what went wrong.
+    const logs = message.indexOf('\nBrowser logs:');
+    if (logs >= 0)
+        message = message.slice(0, logs).trimEnd() + pc.dim('\n(browser log: see the trace)');
+    out.push(message);
+    if (error.snippet && !generated)
+        out.push('', error.snippet);
+    if (error.location && !generated)
+        out.push(pc.dim(`at ${relative(rootDir, error.location.file)}:${error.location.line}`));
+    return out.join('\n');
+}
+function indent(text, n) {
+    const pad = ' '.repeat(n);
+    return text
+        .split('\n')
+        .map((l) => (l ? pad + l : l))
+        .join('\n');
+}
+function seconds(ms) {
+    return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+function quote(p) {
+    return /[\s'"$`\\]/.test(p) ? `'${p.replace(/'/g, `'\\''`)}'` : p;
+}
+//# sourceMappingURL=terminal.js.map

package/dist/workspace-bin.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How to run a package's CLI from the workspace: `[node, <its bin script>]` when the package is
+ * installed there, else `['npx', <bin>]`.
+ *
+ * `npx <bin>` only finds a tool through a `node_modules/.bin` shim. Some layouts have the package
+ * but no shim npx recognises (bun on Windows writes `.bunx` shims), and npx then downloads an
+ * unrelated registry package of the same name: `npx bddgen` fetched `bddgen@1.0.5` and every run
+ * failed with "bddgen failed to generate specs". Resolving the package and running its bin with
+ * this Node works in every layout.
+ */
+export declare function workspaceBin(rootDir: string, pkg: string, bin: string): [string, ...string[]];
+/**
+ * `[file, ...argv]` for a runner tool invocation written as `['playwright', 'test', …]` or
+ * `['bddgen', …]`, resolved through {@link workspaceBin}. Every SDODS command that drives the
+ * runner goes through here rather than a bare `npx`, which can prompt to download a package or
+ * pick up an unrelated one of the same name.
+ */
+export declare function toolCommand(rootDir: string, args: readonly string[]): [string, ...string[]];
+//# sourceMappingURL=workspace-bin.d.ts.map

package/dist/workspace-bin.js

@@ -0,0 +1,46 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+/**
+ * How to run a package's CLI from the workspace: `[node, <its bin script>]` when the package is
+ * installed there, else `['npx', <bin>]`.
+ *
+ * `npx <bin>` only finds a tool through a `node_modules/.bin` shim. Some layouts have the package
+ * but no shim npx recognises (bun on Windows writes `.bunx` shims), and npx then downloads an
+ * unrelated registry package of the same name: `npx bddgen` fetched `bddgen@1.0.5` and every run
+ * failed with "bddgen failed to generate specs". Resolving the package and running its bin with
+ * this Node works in every layout.
+ */
+export function workspaceBin(rootDir, pkg, bin) {
+    try {
+        const manifest = createRequire(join(rootDir, 'package.json')).resolve(`${pkg}/package.json`);
+        const { bin: bins } = JSON.parse(readFileSync(manifest, 'utf8'));
+        const rel = typeof bins === 'string' ? bins : bins?.[bin];
+        if (rel)
+            return [process.execPath, join(dirname(manifest), rel)];
+    }
+    catch {
+        // not resolvable from here: fall back to npx
+    }
+    return ['npx', bin];
+}
+/** The packages behind the runner tools SDODS drives, keyed by the bin name. */
+const TOOL_PACKAGES = {
+    playwright: '@playwright/test',
+    bddgen: 'playwright-bdd',
+};
+/**
+ * `[file, ...argv]` for a runner tool invocation written as `['playwright', 'test', …]` or
+ * `['bddgen', …]`, resolved through {@link workspaceBin}. Every SDODS command that drives the
+ * runner goes through here rather than a bare `npx`, which can prompt to download a package or
+ * pick up an unrelated one of the same name.
+ */
+export function toolCommand(rootDir, args) {
+    const [bin, ...rest] = args;
+    const pkg = bin ? TOOL_PACKAGES[bin] : undefined;
+    if (!bin || !pkg)
+        return ['npx', ...args];
+    const [file, ...pre] = workspaceBin(rootDir, pkg, bin);
+    return [file, ...pre, ...rest];
+}
+//# sourceMappingURL=workspace-bin.js.map

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@sdods/core",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "SDODS runtime: configuration, project registry, fixtures, step libraries, data providers, screenshot narratives and self-healing locators.",
   "license": "Apache-2.0",
+  "funding": "https://sdods.com/sponsor/",
   "author": "SDODS <admin@sdods.com>",
   "type": "module",
   "exports": {
@@ -25,6 +26,7 @@
     "./auth": "./dist/auth/index.js",
     "./insights": "./dist/insights/index.js",
     "./reporters/dashboard": "./dist/reporters/dashboard.js",
+    "./reporters/terminal": "./dist/reporters/terminal.js",
     "./reporters": "./dist/reporters/index.js",
     "./logger": "./dist/logger.js",
     "./auth/capture": "./dist/auth/capture.js"
@@ -44,25 +46,25 @@
     "playwright-bdd": ">=9"
   },
   "dependencies": {
-    "@sdods/contracts": "0.12.0",
+    "@sdods/contracts": "0.13.0",
     "@cucumber/cucumber-expressions": "19.0.0",
     "@cucumber/gherkin": "^42.0.1",
     "@cucumber/messages": "^34.2.1",
     "@faker-js/faker": "^10.6.0",
-    "@scalar/openapi-parser": "^0.29.1",
+    "@scalar/openapi-parser": "^0.29.12",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
-    "csv-parse": "^7.0.2",
+    "csv-parse": "^7.0.3",
     "cucumber-tag-expressions": "^2.0.3",
-    "dotenv": "^17.4.2",
-    "execa": "^10.0.1",
-    "jsonpath-plus": "^10.4.0",
+    "dotenv": "^18.0.7",
+    "execa": "^10.1.0",
+    "jsonpath-plus": "^11.2.0",
     "picocolors": "^1.1.1",
     "ts-morph": "^28.0.0",
-    "tsx": "^4.23.13",
+    "tsx": "^4.23.15",
     "yaml": "^2.9.1",
     "zod": "^4.6.5",
-    "@sdods/db": "0.12.0"
+    "@sdods/db": "0.13.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {