@sdods/core 0.17.0 → 0.19.0

package/dist/import/cucumber.js

@@ -0,0 +1,385 @@
+/**
+ * `sdods import cucumber <dir>`: read a Cucumber-JS suite and plan an SDODS project from it.
+ *
+ * Read-only and side-effect free: the source config and step files are read as text, never
+ * executed (docs/adr/0001-import-existing-suites.md). The caller turns the plan into a proposal.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
+import { CucumberExpression, ParameterType, ParameterTypeRegistry, RegularExpression, } from '@cucumber/cucumber-expressions';
+import { parseFeatureFile } from '../lint/gherkin.js';
+import { coreStepsDir } from '../steps/glob.js';
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.sdods']);
+const LAYER_TAGS = ['@ui', '@api', '@hybrid'];
+const DEFAULT_SUITES = ['@smoke', '@regression', '@sanity'];
+const SDODS_VALUE_KEYS = new Set([
+    'user',
+    'data',
+    'har',
+    'env',
+    'jira',
+    'github',
+    'skip',
+    'matrix',
+]);
+function walk(dir, accept, out = []) {
+    for (const name of readdirSync(dir)) {
+        if (SKIP_DIRS.has(name))
+            continue;
+        const p = join(dir, name);
+        const st = statSync(p);
+        if (st.isDirectory())
+            walk(p, accept, out);
+        else if (accept(p))
+            out.push(p);
+    }
+    return out.sort();
+}
+const lineOf = (text, index) => text.slice(0, index).split('\n').length;
+/** What a step definition's body touches, by the libraries it names. */
+export function classifyStepBody(body) {
+    const ui = /\bpage\.|\bbrowser\b|playwright|puppeteer|webdriver|selenium|\$\(|locator\(/i.test(body);
+    const api = /\bfetch\(|axios|supertest|\brequest\(|\bgot\(|\.get\(['"`]\/|\.post\(['"`]\//.test(body);
+    if (ui && !api)
+        return 'ui';
+    if (api && !ui)
+        return 'api';
+    return ui && api ? 'ui' : 'unknown';
+}
+/**
+ * Step definitions in a Cucumber-JS source file: `Given('…', fn)`, `When(/…/, fn)`, `Then("…")`,
+ * and `defineStep`. Read as text; the body is everything up to the next definition.
+ */
+export function extractStepDefinitions(file, text) {
+    const re = /\b(Given|When|Then|defineStep|Step)\s*\(\s*(?:'((?:\\.|[^'\\])*)'|"((?:\\.|[^"\\])*)"|`((?:\\.|[^`\\])*)`|\/((?:\\.|[^/\\\n])+)\/[a-z]*)/g;
+    const found = [];
+    for (let m = re.exec(text); m; m = re.exec(text))
+        found.push({ m });
+    return found.map(({ m }, i) => {
+        const end = i + 1 < found.length ? found[i + 1].m.index : text.length;
+        const body = text.slice(m.index, end).trimEnd();
+        const regex = m[5] !== undefined;
+        const expression = (m[2] ?? m[3] ?? m[4] ?? m[5] ?? '').replace(/\\(['"`])/g, '$1');
+        return {
+            keyword: m[1],
+            expression,
+            regex,
+            file,
+            line: lineOf(text, m.index),
+            body,
+            kind: classifyStepBody(body),
+        };
+    });
+}
+/** Patterns of the SDODS core step library, read from its source like the source suite's. */
+export function coreStepExpressions(dir = coreStepsDir()) {
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        if (!/\.steps\.(ts|js)$/.test(name))
+            continue;
+        const text = readFileSync(join(dir, name), 'utf8');
+        for (const def of extractStepDefinitions(name, text))
+            if (!def.regex)
+                out.push(def.expression);
+    }
+    return out;
+}
+function registry() {
+    const reg = new ParameterTypeRegistry();
+    const add = (name, re) => {
+        try {
+            reg.defineParameterType(new ParameterType(name, re, String, (s) => s, false, false));
+        }
+        catch {
+            /* already defined */
+        }
+    };
+    add('method', /GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS/);
+    add('role', /button|link|textbox|checkbox|radio|combobox|option|menuitem|tab|heading|dialog|listbox|switch|slider|spinbutton|searchbox|cell|row|img|list|listitem|navigation|banner|main|region|alert|status|form|table|grid|gridcell|tooltip|progressbar|menu|menubar|toolbar|tree|treeitem|article|separator|group/);
+    return reg;
+}
+function matcher(expression, regex, reg) {
+    try {
+        const expr = regex
+            ? new RegularExpression(new RegExp(expression), reg)
+            : new CucumberExpression(expression, reg);
+        return (text) => expr.match(text) !== null;
+    }
+    catch {
+        return undefined; // an unknown custom parameter type: cannot match it, so it never matches
+    }
+}
+/** Literal string values from a Cucumber config file, without running it. */
+export function readCucumberConfig(text) {
+    const list = (key) => {
+        const m = new RegExp(`["']?${key}["']?\\s*:\\s*\\[([^\\]]*)\\]`).exec(text);
+        return m ? [...m[1].matchAll(/["'`]([^"'`]+)["'`]/g)].map((x) => x[1]) : [];
+    };
+    const tags = /["']?tags["']?\s*:\s*["'`]([^"'`]+)["'`]/.exec(text)?.[1];
+    return { paths: list('paths'), requires: [...list('require'), ...list('import')], tags };
+}
+const MANUAL = [
+    { re: /\b(BeforeAll|AfterAll|BeforeStep|AfterStep|Before|After)\s*\(/g, what: 'hook' },
+    { re: /\bsetWorldConstructor\s*\(/g, what: 'custom World' },
+    { re: /\bdefineParameterType\s*\(/g, what: 'custom parameter type' },
+];
+function addTags(content, edits) {
+    const lines = content.split('\n');
+    for (const e of [...edits].sort((a, b) => b.line - a.line)) {
+        if (e.tags.length === 0)
+            continue;
+        if (e.tagLine !== undefined) {
+            lines[e.tagLine - 1] = `${lines[e.tagLine - 1].trimEnd()} ${e.tags.join(' ')}`;
+        }
+        else {
+            const indent = /^\s*/.exec(lines[e.line - 1] ?? '')[0];
+            lines.splice(e.line - 1, 0, `${indent}${e.tags.join(' ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function planCucumberImport(sourceDir, opts) {
+    const warnings = [];
+    const module = opts.module ?? 'imported';
+    // 1. Config, read as text.
+    const configFile = ['cucumber.js', 'cucumber.cjs', 'cucumber.mjs', 'cucumber.json']
+        .map((f) => join(sourceDir, f))
+        .find((f) => {
+        try {
+            return statSync(f).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+    const config = configFile ? readCucumberConfig(readFileSync(configFile, 'utf8')) : undefined;
+    if (!configFile)
+        warnings.push('No cucumber.js/.cjs/.mjs/.json found; read every *.feature and step file.');
+    else if (config && config.paths.length === 0)
+        warnings.push(`${basename(configFile)} names no literal paths; read every *.feature under the source.`);
+    // 2. Features and step files.
+    const featureFiles = walk(sourceDir, (f) => f.endsWith('.feature'));
+    if (featureFiles.length === 0)
+        warnings.push('No .feature files found.');
+    const codeFiles = walk(sourceDir, (f) => /\.(c|m)?(j|t)s$/.test(f) && !f.endsWith('.d.ts'));
+    const sourceSteps = [];
+    const manual = [];
+    for (const file of codeFiles) {
+        const text = readFileSync(file, 'utf8');
+        if (!/@cucumber\/cucumber|cucumber/.test(text))
+            continue;
+        sourceSteps.push(...extractStepDefinitions(relative(sourceDir, file), text));
+        for (const { re, what } of MANUAL) {
+            for (const m of text.matchAll(re))
+                manual.push({
+                    what: `${what} (${m[1] ?? m[0]})`,
+                    file: relative(sourceDir, file),
+                    line: lineOf(text, m.index),
+                });
+        }
+    }
+    // 3. Matchers.
+    const reg = registry();
+    const core = (opts.coreExpressions ?? coreStepExpressions())
+        .map((e) => matcher(e, false, reg))
+        .filter((m) => Boolean(m));
+    const source = sourceSteps
+        .map((s) => ({ step: s, match: matcher(s.expression, s.regex, reg) }))
+        .filter((s) => Boolean(s.match));
+    const coreHits = new Set();
+    const stubbed = new Map();
+    const undefinedSteps = new Set();
+    const allSteps = new Set();
+    const kindOf = (text) => {
+        allSteps.add(text);
+        if (core.some((m) => m(text))) {
+            coreHits.add(text);
+            return 'core';
+        }
+        const hit = source.find((s) => s.match(text));
+        if (!hit) {
+            undefinedSteps.add(text);
+            return 'none';
+        }
+        stubbed.set(`${hit.step.file}:${hit.step.line}`, hit.step);
+        return hit.step.kind;
+    };
+    // 4. Features: tag each scenario with one layer and one suite tag.
+    const features = [];
+    const mappings = [];
+    const usedTags = new Set();
+    const layers = new Set();
+    for (const file of featureFiles) {
+        const text = readFileSync(file, 'utf8');
+        const parsed = parseFeatureFile(file, text);
+        const rel = relative(sourceDir, file).split(sep).join('/');
+        if (parsed.errors.length) {
+            warnings.push(`${rel}: Gherkin parse error (${parsed.errors[0].message}); copied unchanged.`);
+            features.push({ path: `features/${module}/${rel}`, content: text, scenarios: 0 });
+            continue;
+        }
+        const feature = parsed.document.feature;
+        if (!feature)
+            continue;
+        const edits = [];
+        let count = 0;
+        const visit = (children, inherited) => {
+            for (const child of children) {
+                if (child.rule) {
+                    visit(child.rule.children, [...inherited, ...child.rule.tags.map((t) => t.name)]);
+                    continue;
+                }
+                const sc = child.scenario;
+                if (!sc)
+                    continue;
+                count++;
+                const own = sc.tags.map((t) => t.name);
+                const exampleTags = sc.examples.flatMap((e) => e.tags.map((t) => t.name));
+                const effective = [...inherited, ...own, ...exampleTags];
+                effective.forEach((t) => usedTags.add(t));
+                const kinds = sc.steps.map((s) => kindOf(s.text));
+                const ui = kinds.includes('ui');
+                const api = kinds.includes('api');
+                const inferred = ui && api ? 'hybrid' : api ? 'api' : 'ui';
+                const hasLayer = LAYER_TAGS.find((t) => effective.includes(t));
+                const hasSuite = DEFAULT_SUITES.find((t) => effective.includes(t));
+                const add = [];
+                if (!hasLayer)
+                    add.push(`@${inferred}`);
+                if (!hasSuite)
+                    add.push('@regression');
+                const layer = hasLayer?.slice(1) ?? inferred;
+                layers.add(layer);
+                mappings.push({
+                    feature: rel,
+                    scenario: sc.name,
+                    layer,
+                    layerInferred: !hasLayer && !ui && !api,
+                    suite: hasSuite ?? '@regression',
+                });
+                const lastTag = sc.tags.length
+                    ? Math.max(...sc.tags.map((t) => t.location.line))
+                    : undefined;
+                edits.push({ line: sc.location.line, tagLine: lastTag, tags: add });
+            }
+        };
+        visit(feature.children, feature.tags.map((t) => t.name));
+        features.push({
+            path: `features/${module}/${rel}`,
+            content: addTags(text, edits),
+            scenarios: count,
+        });
+    }
+    // Steps of a Background count too.
+    for (const file of featureFiles) {
+        const parsed = parseFeatureFile(file);
+        for (const child of parsed.document.feature?.children ?? [])
+            for (const s of child.background?.steps ?? [])
+                kindOf(s.text);
+    }
+    // 5. Tags the taxonomy does not know go to tags.extra; SDODS value-tag keys are flagged.
+    const extraTags = [...usedTags]
+        .filter((t) => !LAYER_TAGS.includes(t) && !DEFAULT_SUITES.includes(t))
+        .filter((t) => {
+        const key = /^@([a-z-]+):/.exec(t)?.[1];
+        if (key && SDODS_VALUE_KEYS.has(key)) {
+            warnings.push(`${t} uses the SDODS value-tag key "${key}:" and will be validated as one.`);
+            return false;
+        }
+        return true;
+    })
+        .map((t) => t.slice(1))
+        .sort();
+    // 6. Stubs for steps only the source suite defines.
+    const stubs = [...stubbed.values()];
+    const stepsFile = stubs.length ? renderStubs(stubs) : undefined;
+    const plan = {
+        slug: opts.slug,
+        sourceDir,
+        features,
+        layers: ['ui', 'api', 'hybrid'].filter((l) => layers.has(l)),
+        extraTags,
+        stepsFile,
+        mappings,
+        steps: {
+            total: allSteps.size,
+            core: [...coreHits].sort(),
+            stubbed: stubs.map((s) => s.expression),
+            undefined: [...undefinedSteps].sort(),
+        },
+        manual,
+        warnings,
+        report: '',
+    };
+    if (plan.layers.length === 0)
+        plan.layers = ['ui'];
+    plan.report = renderReport(plan, configFile ? relative(sourceDir, configFile) : undefined);
+    return plan;
+}
+/** Parameters a step expression passes: `{…}` in a Cucumber expression, capture groups in a regex. */
+export function argumentCount(step) {
+    if (!step.regex)
+        return (step.expression.match(/(?<!\\)\{[^}]*\}/g) ?? []).length;
+    return (step.expression.match(/(?<!\\)\((?!\?)/g) ?? []).length;
+}
+function renderStubs(stubs) {
+    const lines = [
+        '// Imported by `sdods import cucumber`. Each step below matched a definition in the source',
+        '// suite and nothing in the SDODS step library. Port the body, using the merged fixtures',
+        '// (page, api, data, user, pages), then delete the throw. See IMPORT-REPORT.md.',
+    ];
+    const keyword = (s) => s.keyword === 'Given' || s.keyword === 'When' || s.keyword === 'Then' ? s.keyword : 'Given';
+    const used = [...new Set(stubs.map(keyword))].sort();
+    lines.push(`import { ${used.join(', ')} } from './fixtures.js';`, '');
+    for (const s of stubs) {
+        const kw = keyword(s);
+        const pattern = s.regex
+            ? `/${s.expression}/`
+            : `'${s.expression.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+        lines.push(`// from ${s.file}:${s.line}`);
+        for (const l of s.body.split('\n').slice(0, 40))
+            lines.push(`//   ${l}`);
+        const args = Array.from({ length: argumentCount(s) }, (_, i) => `_arg${i + 1}: string`);
+        // playwright-bdd checks arity: the fixtures object first, then one argument per parameter.
+        lines.push(`${kw}(${pattern}, async ({}, ${args.join(', ')}) => {`.replace(', ) =>', ') =>'));
+        lines.push(`  throw new Error('not ported yet: ${s.file}:${s.line}');`);
+        lines.push('});', '');
+    }
+    return lines.join('\n');
+}
+function renderReport(plan, configFile) {
+    const scenarios = plan.mappings.length;
+    const inferred = plan.mappings.filter((m) => m.layerInferred);
+    const out = [
+        `# Import report: ${plan.slug}`,
+        '',
+        `Imported from \`${plan.sourceDir}\` by \`sdods import cucumber\`${configFile ? `, config \`${configFile}\` (read, not run)` : ''}.`,
+        '',
+        '| | Count |',
+        '|---|---|',
+        `| Feature files | ${plan.features.length} |`,
+        `| Scenarios | ${scenarios} |`,
+        `| Distinct step texts | ${plan.steps.total} |`,
+        `| Covered by the SDODS step library | ${plan.steps.core.length} |`,
+        `| Stubbed in steps/imported.steps.ts (to port) | ${plan.steps.stubbed.length} |`,
+        `| With no definition anywhere | ${plan.steps.undefined.length} |`,
+        `| Hooks, World and parameter types to port by hand | ${plan.manual.length} |`,
+        '',
+        '## Scenarios',
+        '',
+        '| Feature | Scenario | Layer | Suite |',
+        '|---|---|---|---|',
+        ...plan.mappings.map((m) => `| ${m.feature} | ${m.scenario.replace(/\|/g, '\\|')} | @${m.layer}${m.layerInferred ? ' (guessed)' : ''} | ${m.suite} |`),
+    ];
+    if (inferred.length)
+        out.push('', `${inferred.length} scenario(s) had no browser or HTTP code to go by and were tagged @ui; check them.`);
+    if (plan.steps.undefined.length)
+        out.push('', '## Steps with no definition', '', ...plan.steps.undefined.map((s) => `- ${s}`));
+    if (plan.manual.length)
+        out.push('', '## Port by hand', '', ...plan.manual.map((m) => `- ${m.what} at \`${m.file}:${m.line}\``));
+    if (plan.warnings.length)
+        out.push('', '## Warnings', '', ...plan.warnings.map((w) => `- ${w}`));
+    out.push('', '## Next', '', `1. \`sdods lint -p ${plan.slug}\` (it should pass as imported).`, `2. Set the base URLs in \`envs/\`, then \`sdods run -p ${plan.slug} -l api\` / \`-l ui\`.`, '3. Port the stubs in `steps/imported.steps.ts`; each one fails with `not ported yet` until then.', '');
+    return out.join('\n');
+}
+//# sourceMappingURL=cucumber.js.map

package/dist/import/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cucumber.js';
+export * from './playwright.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/import/index.js

@@ -0,0 +1,3 @@
+export * from './cucumber.js';
+export * from './playwright.js';
+//# sourceMappingURL=index.js.map

package/dist/import/playwright.d.ts

@@ -0,0 +1,12 @@
+export interface PlaywrightImportAnalysis {
+    sourceDir: string;
+    specFiles: string[];
+    tests: number;
+    describes: number;
+    fixtures: string[];
+    pageObjects: string[];
+    configFile?: string;
+    report: string;
+}
+export declare function analyzePlaywrightSuite(sourceDir: string, slug: string): PlaywrightImportAnalysis;
+//# sourceMappingURL=playwright.d.ts.map

package/dist/import/playwright.js

@@ -0,0 +1,90 @@
+/**
+ * `sdods import playwright <dir>`: analysis only, for now (docs/adr/0001-import-existing-suites.md).
+ *
+ * Counts what a Playwright Test suite is made of so a person can judge the port. It converts
+ * nothing: mapping imperative specs onto Gherkin gets its own design.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+const SKIP = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    'test-results',
+    'playwright-report',
+]);
+function walk(dir, out = []) {
+    for (const name of readdirSync(dir)) {
+        if (SKIP.has(name))
+            continue;
+        const p = join(dir, name);
+        if (statSync(p).isDirectory())
+            walk(p, out);
+        else
+            out.push(p);
+    }
+    return out.sort();
+}
+export function analyzePlaywrightSuite(sourceDir, slug) {
+    const files = walk(sourceDir);
+    const rel = (f) => relative(sourceDir, f);
+    const specFiles = files.filter((f) => /\.(spec|test)\.(c|m)?(j|t)s$/.test(f)).map(rel);
+    const configFile = files.map(rel).find((f) => /^playwright\.config\.(c|m)?(j|t)s$/.test(f));
+    let tests = 0;
+    let describes = 0;
+    const fixtures = new Set();
+    const pageObjects = [];
+    for (const f of files) {
+        if (!/\.(c|m)?(j|t)s$/.test(f))
+            continue;
+        const text = readFileSync(f, 'utf8');
+        if (specFiles.includes(rel(f))) {
+            tests += [...text.matchAll(/\btest(\.only|\.skip|\.fixme)?\s*\(\s*['"`]/g)].length;
+            describes += [...text.matchAll(/\btest\.describe(\.\w+)?\s*\(/g)].length;
+        }
+        for (const m of text.matchAll(/\.extend<\{([^}]*)\}>/g))
+            for (const k of m[1].matchAll(/(\w+)\s*:/g))
+                fixtures.add(k[1]);
+        if (/class\s+\w+Page\b/.test(text) || /\/pages?\//.test(f))
+            pageObjects.push(rel(f));
+    }
+    const analysis = {
+        sourceDir,
+        specFiles,
+        tests,
+        describes,
+        fixtures: [...fixtures].sort(),
+        pageObjects,
+        configFile,
+        report: '',
+    };
+    analysis.report = [
+        `# Import analysis: ${slug} (Playwright)`,
+        '',
+        `Read from \`${sourceDir}\` by \`sdods import playwright\`. Nothing was converted: this command`,
+        'only analyses a Playwright suite for now (docs/adr/0001-import-existing-suites.md).',
+        '',
+        '| | Count |',
+        '|---|---|',
+        `| Spec files | ${specFiles.length} |`,
+        `| Tests | ${tests} |`,
+        `| describe blocks | ${describes} |`,
+        `| Custom fixtures | ${analysis.fixtures.length}${analysis.fixtures.length ? ` (${analysis.fixtures.join(', ')})` : ''} |`,
+        `| Page objects | ${pageObjects.length} |`,
+        `| Config | ${configFile ?? 'none found'} |`,
+        '',
+        '## Ways in today',
+        '',
+        `- Run the specs as they are on the \`recorded\` layer: \`sdods analyze <dir> --apply\` copies them into \`projects/<slug>/recorded/imported/\`, then \`sdods run -p <slug> -l recorded\`.`,
+        '- Convert one spec at a time into a feature, steps and a page object with `sdods record convert <spec>` (a proposal).',
+        '',
+        '## Spec files',
+        '',
+        ...specFiles.map((f) => `- ${f}`),
+        '',
+    ].join('\n');
+    return analysis;
+}
+//# sourceMappingURL=playwright.js.map

package/dist/index.d.ts

@@ -20,4 +20,5 @@ export { coreStepsGlob, coreStepsPatterns, coreStepNames, coreStepsDir } from '.
 export { VERSION } from './version.js';
 export * from './matrix/index.js';
 export * from './quality/index.js';
+export * from './import/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -19,4 +19,5 @@ export { coreStepsGlob, coreStepsPatterns, coreStepNames, coreStepsDir } from '.
 export { VERSION } from './version.js';
 export * from './matrix/index.js';
 export * from './quality/index.js';
+export * from './import/index.js';
 //# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -1,4 +1,6 @@
 export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'step' | 'debug';
+/** `scheme://user:password@host` → `scheme://user:***@host`, for config values such as a DB URL. */
+export declare function maskUrlPassword(value: string): string;
 export declare function isSecretKey(name: string): boolean;
 export declare function setLogLevel(level: LogLevel): void;
 export declare function setLogJson(enabled: boolean): void;

package/dist/logger.js

@@ -10,7 +10,11 @@ const ORDER = {
 let globalLevel = process.env.SDODS_LOG_LEVEL || 'info';
 let jsonMode = process.env.SDODS_LOG_JSON === '1';
 /** Key names whose string values are credentials: config fields, header names, log fields. */
-const SECRET_KEY = /(passw(or)?d|secret|token|api[-_]?key|[-_]key$|authorization|cookie|credential)/i;
+const SECRET_KEY = /(passw(or)?d|passphrase|secret|token|api[-_]?key|[-_]key$|private[-_]?key|authorization|cookie|credential|pwd|[-_]pw$|^pin$|(^|[-_])otp|(^|[-_])dsn$)/i;
+/** `scheme://user:password@host` → `scheme://user:***@host`, for config values such as a DB URL. */
+export function maskUrlPassword(value) {
+    return value.replace(/^([a-z][a-z0-9+.-]*:\/\/[^/:@\s]*):[^@/\s]+@/i, '$1:***@');
+}
 export function isSecretKey(name) {
     return SECRET_KEY.test(name);
 }
@@ -38,6 +42,8 @@ export function redact(value, depth = 0) {
         }
         return out;
     }
+    if (typeof value === 'string')
+        return maskUrlPassword(value);
     return value;
 }
 function ts() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/core",
-  "version": "0.17.0",
+  "version": "0.19.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/",
@@ -46,25 +46,26 @@
     "playwright-bdd": ">=9"
   },
   "dependencies": {
-    "@sdods/contracts": "0.17.0",
+    "@sdods/contracts": "0.19.0",
     "@cucumber/cucumber-expressions": "19.0.1",
     "@cucumber/gherkin": "^42.0.1",
     "@cucumber/messages": "^34.2.1",
     "@faker-js/faker": "^10.6.0",
-    "@scalar/openapi-parser": "^0.29.16",
+    "@scalar/openapi-parser": "^0.29.19",
     "ajv": "^8.20.0",
+    "allure-playwright": "3.13.0",
     "ajv-formats": "^3.0.1",
     "csv-parse": "^7.0.3",
     "@cucumber/tag-expressions": "^11.0.1",
     "dotenv": "^18.0.9",
     "execa": "^10.2.1",
-    "jsonpath-plus": "^11.2.1",
+    "jsonpath-plus": "^11.2.2",
     "picocolors": "^1.1.1",
     "ts-morph": "^28.0.0",
     "tsx": "^4.23.15",
     "yaml": "^2.9.1",
     "zod": "^4.6.7",
-    "@sdods/db": "0.17.0"
+    "@sdods/db": "0.19.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {
@@ -72,7 +73,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/YarlisAISolutions/SDODS.git",
+    "url": "git+https://github.com/YarlisAISolutions/sdods.git",
     "directory": "packages/core"
   },
   "keywords": [