@sdods/core 0.2.2 → 0.3.0

package/dist/steps/webhook.steps.d.ts

@@ -0,0 +1,46 @@
+import { type Server } from 'node:http';
+import './params.js';
+/**
+ * An ephemeral callback receiver, for the leg where the application calls BACK.
+ *
+ * WHY — 16 trigger providers deliver by webhook. Without a receiver a suite can
+ * assert that a subscription was created and nothing about whether a delivery
+ * ever arrived, which is the half that actually matters: a trigger that
+ * registers and never fires looks identical to a working one.
+ *
+ * DESIGN — the server binds to an EPHEMERAL port on 127.0.0.1 and its URL is
+ * published into the scenario's template scope as `{{callback.url}}`, so the
+ * scenario never hardcodes a port. It is torn down at scenario end even when
+ * the scenario fails; a leaked listener silently poisons the next run on the
+ * same worker, and that is the kind of failure nobody traces back.
+ *
+ * Deliveries are recorded in arrival order and asserted by POLLING, never by
+ * sleeping. "Wait two seconds then check" is how a webhook suite becomes both
+ * slow and flaky at the same time.
+ *
+ * NOT a public tunnel. This receives from an application that can reach the
+ * runner — a local or in-VPC app under test. Reaching a hosted staging
+ * deployment needs a tunnel, which is an infrastructure decision rather than
+ * something a step library should quietly stand up.
+ */
+export interface Delivery {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    body: string;
+    receivedAt: number;
+}
+export interface Receiver {
+    server: Server;
+    url: string;
+    deliveries: Delivery[];
+}
+/**
+ * Extracted from the step so the receiver itself is testable without a browser,
+ * a config or a Playwright runner. It is the most intricate piece here — an
+ * HTTP server, async body reading and a shared array — and "it worked when I
+ * tried it" is not a claim anyone can re-check later.
+ */
+export declare function startReceiver(): Promise<Receiver>;
+export declare function closeAllReceivers(): Promise<void>;
+//# sourceMappingURL=webhook.steps.d.ts.map

package/dist/steps/webhook.steps.js

@@ -0,0 +1,129 @@
+import { createServer } from 'node:http';
+import { expect } from '@playwright/test';
+import './params.js';
+import { AfterScenario, Given, Then, When } from '../fixtures/test.js';
+import { render } from '../api/template.js';
+import { SdodsError } from '../errors.js';
+const receivers = new Map();
+function key(apiContext) {
+    return String(apiContext.runId ?? 'default');
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+function requireReceiver(k) {
+    const r = receivers.get(k);
+    if (!r) {
+        throw new SdodsError('NOT_SUPPORTED', 'No callback receiver is listening.', {
+            hint: 'Use `Given a callback receiver is listening` first; its URL is available as {{callback.url}}.',
+        });
+    }
+    return r;
+}
+/**
+ * Extracted from the step so the receiver itself is testable without a browser,
+ * a config or a Playwright runner. It is the most intricate piece here — an
+ * HTTP server, async body reading and a shared array — and "it worked when I
+ * tried it" is not a claim anyone can re-check later.
+ */
+export async function startReceiver() {
+    const deliveries = [];
+    const server = createServer((req, res) => {
+        void readBody(req).then((body) => {
+            deliveries.push({
+                method: req.method ?? 'GET',
+                path: req.url ?? '/',
+                headers: Object.fromEntries(Object.entries(req.headers).map(([h, v]) => [
+                    h,
+                    Array.isArray(v) ? v.join(', ') : (v ?? ''),
+                ])),
+                body,
+                receivedAt: Date.now(),
+            });
+            // 200 with an empty body: a provider that retries on a non-2xx would
+            // otherwise deliver the same event repeatedly and the counts below would
+            // be meaningless.
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end('{}');
+        });
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new SdodsError('INTERNAL', 'The callback receiver did not report a port.');
+    }
+    return { server, url: `http://127.0.0.1:${address.port}`, deliveries };
+}
+Given('a callback receiver is listening', async ({ apiContext }) => {
+    const k = key(apiContext);
+    if (receivers.has(k))
+        return;
+    const receiver = await startReceiver();
+    receivers.set(k, receiver);
+    // Published as a scope value so the scenario writes {{callback.url}} rather
+    // than a port it cannot know.
+    apiContext.vars.set('callback', {
+        url: receiver.url,
+    });
+});
+When('I stop the callback receiver', async ({ apiContext }) => {
+    const k = key(apiContext);
+    const r = receivers.get(k);
+    if (!r)
+        return;
+    await new Promise((resolve) => r.server.close(() => resolve()));
+    receivers.delete(k);
+});
+Then('the callback receiver should receive {int} delivery/deliveries', async ({ apiContext }, count) => {
+    const r = requireReceiver(key(apiContext));
+    await expect
+        .poll(() => r.deliveries.length, {
+        message: `expected ${count} callback delivery/deliveries`,
+    })
+        .toBe(count);
+});
+Then('the callback receiver should receive a delivery', async ({ apiContext }) => {
+    const r = requireReceiver(key(apiContext));
+    await expect
+        .poll(() => r.deliveries.length, { message: 'no callback delivery arrived' })
+        .toBeGreaterThan(0);
+});
+Then('the callback receiver should receive a delivery containing {string}', async ({ apiContext, env }, text) => {
+    const r = requireReceiver(key(apiContext));
+    const needle = render(text, apiContext.vars.toObject(), env.vars);
+    await expect
+        .poll(() => r.deliveries.some((d) => d.body.includes(needle)), {
+        message: `no callback delivery contained "${needle}"`,
+    })
+        .toBe(true);
+});
+Then('the last callback delivery should have the header {string} set to {string}', async ({ apiContext, env }, header, value) => {
+    const r = requireReceiver(key(apiContext));
+    await expect
+        .poll(() => r.deliveries.length, { message: 'no callback delivery arrived' })
+        .toBeGreaterThan(0);
+    const scopes = [
+        apiContext.vars.toObject(),
+        env.vars,
+    ];
+    const last = r.deliveries[r.deliveries.length - 1];
+    expect(last.headers[render(header, ...scopes).toLowerCase()]).toBe(render(value, ...scopes));
+});
+/**
+ * Torn down after EVERY scenario, including a failing one — hence a hook rather
+ * than a step. A leaked listener silently poisons the next scenario on the same
+ * worker, and that is a failure nobody traces back to the scenario that leaked.
+ */
+AfterScenario(async () => {
+    await closeAllReceivers();
+});
+export async function closeAllReceivers() {
+    for (const [k, r] of receivers) {
+        await new Promise((resolve) => r.server.close(() => resolve()));
+        receivers.delete(k);
+    }
+}
+//# sourceMappingURL=webhook.steps.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/core",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "SDODS runtime: configuration, project registry, fixtures, step libraries, data providers, screenshot narratives and self-healing locators.",
   "license": "Apache-2.0",
   "author": "SDODS <admin@sdods.com>",
@@ -42,14 +42,13 @@
     "playwright-bdd": ">=9"
   },
   "dependencies": {
-    "@sdods/contracts": "0.2.2",
+    "@sdods/contracts": "0.3.0",
     "@cucumber/gherkin": "^42.0.1",
     "@cucumber/messages": "^34.2.1",
     "@faker-js/faker": "^10.6.0",
     "@scalar/openapi-parser": "^0.29.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
-    "chart.js": "^4.5.1",
     "csv-parse": "^7.0.2",
     "cucumber-tag-expressions": "^2.0.3",
     "dotenv": "^17.4.2",
@@ -59,7 +58,7 @@
     "ts-morph": "^28.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.5.4",
-    "@sdods/db": "0.2.2"
+    "@sdods/db": "0.3.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {

package/dist/analyze/modules.d.ts

@@ -1,74 +0,0 @@
-import type { AnalysisReport, Evidence, Layer } from '@sdods/contracts';
-/**
- * Module detection by signal fusion.
- *
- * Every detector casts weighted votes for "which module owns this route/endpoint"; the
- * resolver keeps the strongest vote per target, then drops noise, merges aliases and splits
- * oversized modules. Replaces the two independent first-URL-segment groupers that used to
- * live in propose.ts and mcp/tools/analyze.ts.
- *
- * The ordering matters more than any individual rule. Measured against
- * cypress-realworld-app (17 routes): first-URL-segment yields 14 groups, the source-file
- * signal alone yields 8, and `backend/auth.ts` collapses /checkAuth + /login + /logout into
- * one module without consulting the alias table at all.
- */
-export type ModuleSignal = 'openapi-tag' | 'workspace' | 'framework-module' | 'domain-dir' | 'source-file' | 'har' | 'route-segment' | 'alias';
-export declare const SIGNAL_WEIGHTS: Record<ModuleSignal, number>;
-export interface ModuleVote {
-    /** the thing being assigned: a route or endpoint path */
-    target: string;
-    kind: 'route' | 'endpoint';
-    module: string;
-    weight: number;
-    signal: ModuleSignal;
-    layer: Layer;
-    evidence: Evidence;
-}
-export interface DetectedModule {
-    name: string;
-    layers: Layer[];
-    routes: string[];
-    endpoints: string[];
-    testingTypes: string[];
-    tags: string[];
-    /** mean weight of the winning votes; 0..1 */
-    confidence: number;
-    signals: ModuleSignal[];
-    evidence: Evidence[];
-    /** populated by the split pass; recorded in the report, not yet emitted to yaml */
-    children?: DetectedModule[];
-}
-export interface DetectModulesOptions {
-    /** a module with more targets than this splits into children (default 12) */
-    splitAfter?: number;
-    /** a module with this many targets or fewer merges into an alias sibling (default 1) */
-    mergeBelow?: number;
-    maxModules?: number;
-}
-export interface DetectModulesResult {
-    modules: DetectedModule[];
-    votes: ModuleVote[];
-    /** targets deliberately not turned into modules, with the reason */
-    ignored: Array<{
-        target: string;
-        reason: string;
-    }>;
-}
-/**
- * Synonyms folded onto a canonical module name. Merges only; an alias never creates a module,
- * which is why the weight is the lowest in the table.
- */
-export declare const MODULE_ALIASES: Record<string, string[]>;
-export declare function canonicalAlias(name: string): string | undefined;
-/** Today's rule, kept: demoted to a weak signal, and reused as the sub-module split rule. */
-export declare function moduleOfPath(path: string): string;
-/**
- * Module name from the file that defines a route. Returns undefined when the file names a role
- * rather than a domain (`backend/app.ts`), so a weaker signal can take over.
- *
- * `backend/auth.ts` -> auth; `bankaccount-routes.ts` -> bankaccount;
- * `TransactionsContainer.tsx` -> transactions; `backend/app.ts` -> undefined.
- */
-export declare function moduleOfFile(file: string): string | undefined;
-export declare function detectModules(report: AnalysisReport, opts?: DetectModulesOptions): DetectModulesResult;
-//# sourceMappingURL=modules.d.ts.map

package/dist/analyze/modules.js

@@ -1,353 +0,0 @@
-import { slugify } from './propose.js';
-export const SIGNAL_WEIGHTS = {
-    'openapi-tag': 1.0,
-    workspace: 0.9,
-    'framework-module': 0.85,
-    'domain-dir': 0.8,
-    'source-file': 0.7,
-    har: 0.5,
-    'route-segment': 0.3,
-    alias: 0.2,
-};
-/** Path segments that never name a domain. */
-const RESERVED_SEGMENTS = new Set(['api', 'app', 'src', 'pages']);
-/** Basenames that name a file's role, not its domain. */
-const GENERIC_BASENAMES = new Set(['index', 'app', 'main', 'server', 'routes', 'route', 'router']);
-/** Directories that group by layer, not by domain. */
-const GENERIC_DIRS = new Set([
-    'src',
-    'backend',
-    'frontend',
-    'api',
-    'lib',
-    'app',
-    'pages',
-    'containers',
-    'views',
-    'components',
-    'routes',
-    'server',
-]);
-/** Directories that conventionally hold one subdirectory per domain. */
-const DOMAIN_DIR_RE = /(?:^|\/)(?:src\/)?(?:modules|features|domains|containers|views|pages|apps|services)\/([^/]+)\//;
-/** Route-param and route-group directories: `[id]`, `[...slug]`, `{id}`, `:id`, `(marketing)`. */
-const DYNAMIC_DIR_RE = /^(?:\[.*\]|\{.*\}|:.+|\(.*\))$/;
-/** Suffixes that describe a file's role and should be stripped before naming a module. */
-const ROLE_SUFFIX_RE = /[-_.]?(routes?|router|controller|container|service|module|handler|page|view|screen|api)$/i;
-/**
- * Synonyms folded onto a canonical module name. Merges only; an alias never creates a module,
- * which is why the weight is the lowest in the table.
- */
-export const MODULE_ALIASES = {
-    auth: [
-        'login',
-        'signin',
-        'sign-in',
-        'logout',
-        'signout',
-        'sign-out',
-        'signup',
-        'sign-up',
-        'register',
-        'session',
-        'checkauth',
-        'check-auth',
-        'oauth',
-        'sso',
-        'identity',
-    ],
-    user: ['users', 'profile', 'profiles', 'me', 'account', 'accounts'],
-    admin: ['administration', 'backoffice', 'back-office'],
-    search: ['searches', 'query'],
-};
-const ALIAS_TO_CANONICAL = (() => {
-    const out = {};
-    for (const [canonical, names] of Object.entries(MODULE_ALIASES)) {
-        for (const n of names)
-            out[n] = canonical;
-    }
-    return out;
-})();
-export function canonicalAlias(name) {
-    return ALIAS_TO_CANONICAL[name];
-}
-/** Today's rule, kept: demoted to a weak signal, and reused as the sub-module split rule. */
-export function moduleOfPath(path) {
-    const first = path.split('/').filter(Boolean)[0];
-    if (!first || first.startsWith('{'))
-        return 'home';
-    const clean = first.replace(/[^a-zA-Z0-9]+/g, '-').toLowerCase();
-    return RESERVED_SEGMENTS.has(clean) ? 'core' : clean;
-}
-/**
- * Module name from the file that defines a route. Returns undefined when the file names a role
- * rather than a domain (`backend/app.ts`), so a weaker signal can take over.
- *
- * `backend/auth.ts` -> auth; `bankaccount-routes.ts` -> bankaccount;
- * `TransactionsContainer.tsx` -> transactions; `backend/app.ts` -> undefined.
- */
-export function moduleOfFile(file) {
-    const parts = file.replace(/\\/g, '/').split('/').filter(Boolean);
-    const base = (parts.pop() ?? '').replace(/\.[^.]+$/, '');
-    let name = base.replace(ROLE_SUFFIX_RE, '');
-    if (!name || GENERIC_BASENAMES.has(name.toLowerCase())) {
-        // File-router frameworks put the domain further up: `app/products/[id]/page.tsx` is the
-        // `products` module, not `id`. Walk past dynamic segments and route groups.
-        name = '';
-        while (parts.length) {
-            const dir = parts.pop();
-            if (DYNAMIC_DIR_RE.test(dir))
-                continue;
-            if (GENERIC_DIRS.has(dir.toLowerCase()))
-                return undefined;
-            name = dir;
-            break;
-        }
-        if (!name)
-            return undefined;
-    }
-    // split camelCase/PascalCase before slugify so TransactionsContainer -> transactions
-    const slug = slugify(name.replace(/([a-z0-9])([A-Z])/g, '$1-$2'));
-    if (!slug || slug === 'app' || GENERIC_DIRS.has(slug))
-        return undefined;
-    return slug;
-}
-/**
- * Routes that carry no domain information and must not become modules.
- *
- * A path that is uninformative on its own is still fine when its defining file names a domain:
- * `GET /{username}` in `backend/contact-routes.ts` is the `contact` module, and dropping it
- * would lose a real module. So parameter-only and root routes are noise only when the file
- * cannot name them either. Catch-all and optional-group routes are never valid test targets.
- */
-function noiseReason(r) {
-    const p = r.path;
-    if (/^\/?\*/.test(p))
-        return 'catch-all route';
-    if (/\(.*\)\?/.test(p))
-        return 'optional-group route';
-    if (moduleOfFile(r.file))
-        return undefined;
-    const segs = p.split('/').filter(Boolean);
-    // a UI root path is a real, nameable screen (home); an API root carries nothing
-    if (segs.length === 0)
-        return r.kind === 'page' ? undefined : 'root route in a generic file';
-    if (segs.length === 1 && /^[{:]/.test(segs[0]))
-        return 'bare parameter route in a generic file';
-    return undefined;
-}
-function layerOf(r) {
-    return r.kind === 'api' ? 'api' : 'ui';
-}
-function longestWorkspaceMatch(file, workspaces) {
-    let best;
-    for (const w of workspaces) {
-        const prefix = w.replace(/\/?\*+$/, '').replace(/\/$/, '');
-        if (!prefix)
-            continue;
-        if (file === prefix || file.startsWith(`${prefix}/`)) {
-            if (!best || prefix.length > best.length)
-                best = prefix;
-        }
-    }
-    if (!best)
-        return undefined;
-    // the workspace dir itself is generic (packages/, apps/) - name the package under it
-    const rest = file.slice(best.length).split('/').filter(Boolean)[0];
-    return rest ? slugify(rest) : undefined;
-}
-export function detectModules(report, opts = {}) {
-    const splitAfter = opts.splitAfter ?? 12;
-    const mergeBelow = opts.mergeBelow ?? 1;
-    const maxModules = opts.maxModules ?? 30;
-    const votes = [];
-    const ignored = [];
-    const cast = (v) => {
-        if (v.module)
-            votes.push(v);
-    };
-    // S1 openapi-tag (1.0) - the authoritative API grouping when a spec exists
-    const tagged = new Set();
-    for (const spec of report.openapi) {
-        for (const e of spec.endpoints) {
-            if (!e.tag)
-                continue;
-            tagged.add(e.path);
-            cast({
-                target: e.path,
-                kind: 'endpoint',
-                module: slugify(e.tag),
-                weight: SIGNAL_WEIGHTS['openapi-tag'],
-                signal: 'openapi-tag',
-                layer: 'api',
-                evidence: { file: spec.file, snippet: `tag: ${e.tag}` },
-            });
-        }
-    }
-    const workspaces = report.packageManager.workspaces ?? [];
-    for (const r of report.routes) {
-        if (tagged.has(r.path))
-            continue;
-        const reason = noiseReason(r);
-        if (reason) {
-            ignored.push({ target: r.path, reason });
-            continue;
-        }
-        const kind = r.kind === 'api' ? 'endpoint' : 'route';
-        const layer = layerOf(r);
-        const ev = { file: r.file, line: r.line, snippet: r.path };
-        // S2 workspace (0.9)
-        const ws = longestWorkspaceMatch(r.file, workspaces);
-        if (ws) {
-            cast({
-                target: r.path,
-                kind,
-                module: ws,
-                weight: SIGNAL_WEIGHTS.workspace,
-                signal: 'workspace',
-                layer,
-                evidence: ev,
-            });
-        }
-        // S3 domain-dir (0.8)
-        const dd = DOMAIN_DIR_RE.exec(r.file.replace(/\\/g, '/'));
-        if (dd?.[1] && !GENERIC_DIRS.has(dd[1].toLowerCase())) {
-            cast({
-                target: r.path,
-                kind,
-                module: slugify(dd[1]),
-                weight: SIGNAL_WEIGHTS['domain-dir'],
-                signal: 'domain-dir',
-                layer,
-                evidence: ev,
-            });
-        }
-        // S4 source-file (0.7) - the primary signal
-        const mf = moduleOfFile(r.file);
-        if (mf) {
-            cast({
-                target: r.path,
-                kind,
-                module: mf,
-                weight: SIGNAL_WEIGHTS['source-file'],
-                signal: 'source-file',
-                layer,
-                evidence: ev,
-            });
-        }
-        // S5 route-segment (0.3) - today's rule, kept as the floor so nothing goes unassigned
-        cast({
-            target: r.path,
-            kind,
-            module: moduleOfPath(r.path),
-            weight: SIGNAL_WEIGHTS['route-segment'],
-            signal: 'route-segment',
-            layer,
-            evidence: ev,
-        });
-    }
-    // resolve: strongest vote per target
-    const winners = new Map();
-    for (const v of votes) {
-        const cur = winners.get(v.target);
-        if (!cur || v.weight > cur.weight)
-            winners.set(v.target, v);
-    }
-    // build modules
-    const acc = new Map();
-    for (const v of winners.values()) {
-        const m = acc.get(v.module) ?? {
-            routes: new Set(),
-            endpoints: new Set(),
-            layers: new Set(),
-            signals: new Set(),
-            evidence: [],
-            weights: [],
-            contract: false,
-        };
-        if (v.kind === 'endpoint')
-            m.endpoints.add(v.target);
-        else
-            m.routes.add(v.target);
-        m.layers.add(v.layer);
-        m.signals.add(v.signal);
-        m.weights.push(v.weight);
-        if (v.signal === 'openapi-tag')
-            m.contract = true;
-        if (m.evidence.length < 5)
-            m.evidence.push(v.evidence);
-        acc.set(v.module, m);
-    }
-    // alias merge - folds signin/signup (generic App.tsx) into auth (backend/auth.ts)
-    for (const [name, m] of [...acc.entries()]) {
-        const canonical = canonicalAlias(name);
-        const size = m.routes.size + m.endpoints.size;
-        if (canonical && canonical !== name && acc.has(canonical)) {
-            const t = acc.get(canonical);
-            for (const r of m.routes)
-                t.routes.add(r);
-            for (const e of m.endpoints)
-                t.endpoints.add(e);
-            for (const l of m.layers)
-                t.layers.add(l);
-            t.signals.add('alias');
-            t.weights.push(...m.weights);
-            for (const e of m.evidence)
-                if (t.evidence.length < 5)
-                    t.evidence.push(e);
-            acc.delete(name);
-        }
-        else if (size <= mergeBelow && !canonical && acc.size > 1) {
-            // a singleton that nothing claims stays put rather than inventing a bucket;
-            // it is the caller's job (detect.ignore) to drop it if it is noise.
-        }
-    }
-    let modules = [...acc.entries()].map(([name, m]) => {
-        const testingTypes = ['functional', 'smoke', 'regression'];
-        if (m.contract)
-            testingTypes.push('contract');
-        if (canonicalAlias(name) === 'auth' || name === 'auth')
-            testingTypes.push('data-driven');
-        const targets = [...m.routes, ...m.endpoints];
-        const mod = {
-            name,
-            layers: [...m.layers],
-            routes: [...m.routes],
-            endpoints: [...m.endpoints],
-            testingTypes,
-            tags: [`@${name}`],
-            confidence: m.weights.length ? m.weights.reduce((a, b) => a + b, 0) / m.weights.length : 0,
-            signals: [...m.signals],
-            evidence: m.evidence,
-        };
-        // split pass: reuse the old first-segment rule where it is actually correct
-        if (targets.length > splitAfter) {
-            const groups = new Map();
-            for (const t of targets) {
-                const k = moduleOfPath(t);
-                groups.set(k, [...(groups.get(k) ?? []), t]);
-            }
-            if (groups.size > 1) {
-                mod.children = [...groups.entries()].map(([childName, ts]) => ({
-                    name: childName,
-                    layers: mod.layers,
-                    routes: ts.filter((t) => m.routes.has(t)),
-                    endpoints: ts.filter((t) => m.endpoints.has(t)),
-                    testingTypes: mod.testingTypes,
-                    tags: [`@${name}`, `@${name}/${childName}`],
-                    confidence: mod.confidence,
-                    signals: ['route-segment'],
-                    evidence: [],
-                }));
-            }
-        }
-        return mod;
-    });
-    modules.sort((a, b) => b.confidence - a.confidence ||
-        b.routes.length + b.endpoints.length - (a.routes.length + a.endpoints.length) ||
-        a.name.localeCompare(b.name));
-    if (modules.length > maxModules)
-        modules = modules.slice(0, maxModules);
-    return { modules, votes, ignored };
-}
-//# sourceMappingURL=modules.js.map

package/dist/config/playwright.d.ts

@@ -1,37 +0,0 @@
-import { type PlaywrightTestConfig } from '@playwright/test';
-import { type BrowserName, type Layer } from '@sdods/contracts';
-import type { ProjectRegistry } from './registry.js';
-export interface PlaywrightSelection {
-    project?: string;
-    env?: string;
-    layers?: string[];
-    browsers?: string[];
-    tags?: string;
-    runId?: string;
-    lint?: boolean;
-    allure?: boolean;
-    reporters?: string[];
-    reporterMode?: 'default' | 'server' | 'quiet';
-}
-export interface SdodsUseOption {
-    project: string;
-    layer: Layer;
-    browser?: BrowserName;
-}
-export declare const DASHBOARD_REPORTER = "@sdods/core/reporters/dashboard";
-/** Convenience for `playwright.config.ts`: read the selection from SDODS_* env vars. */
-export declare function selectionFromEnv(env?: NodeJS.ProcessEnv): PlaywrightSelection;
-export interface GeneratedProject {
-    name: string;
-    project: string;
-    layer: Layer;
-    browser?: BrowserName;
-}
-/** Names (and identity) of the Playwright projects a selection would produce, without side effects. */
-export declare function listGeneratedProjects(registry: ProjectRegistry, sel: PlaywrightSelection): GeneratedProject[];
-/**
- * Build the Playwright config for a selection of projects × layers × browsers.
- * One `defineBddConfig` per project × layer; browsers reuse the generated testDir.
- */
-export declare function buildPlaywrightConfig(registry: ProjectRegistry, sel?: PlaywrightSelection): PlaywrightTestConfig;
-//# sourceMappingURL=playwright.d.ts.map