@sdods/cli 0.8.0 → 0.9.0

package/dist/commands/baselines.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function register(program: Command): void;
+//# sourceMappingURL=baselines.d.ts.map

package/dist/commands/baselines.js

@@ -0,0 +1,111 @@
+import { relative, resolve as resolvePath } from 'node:path';
+import pc from 'picocolors';
+import { DEFAULT_ARTIFACTS_DIR, SdodsError, acceptVisualFailures, listVisualFailures, selectVisualFailures, } from '@sdods/core';
+import { createContext } from '../context.js';
+import { heading, json, ok, out, table } from '../ui.js';
+import { listRuns } from './trace.js';
+function artifactsDirOf(ctx, flag) {
+    return resolvePath(ctx.rootDir, flag ?? process.env.SDODS_ARTIFACTS_DIR ?? DEFAULT_ARTIFACTS_DIR);
+}
+function findRun(ctx, opts) {
+    const artifactsDir = artifactsDirOf(ctx, opts.artifactsDir);
+    const runs = listRuns(artifactsDir);
+    const run = opts.run ? runs.find((r) => r.runId === opts.run) : runs[0];
+    if (!run)
+        throw new SdodsError('CONFIG_NOT_FOUND', opts.run
+            ? `Run ${opts.run} not found under ${artifactsDir}.`
+            : `No runs under ${artifactsDir}.`, {
+            hint: 'Run `sdods run -t @visual …` first, or download the CI run into .sdods/runs/<id>.',
+            exitCode: 2,
+        });
+    return run;
+}
+const pct = (r) => (r === undefined ? '' : `${(r * 100).toFixed(2)}%`);
+export function register(program) {
+    const baselines = program
+        .command('baselines')
+        .description('Review failed visual baseline checks of a run and accept the new screenshots');
+    baselines
+        .command('diff')
+        .description('List the visual checks that failed in a run: expected, actual and diff images')
+        .option('--run <id>', 'run id (default: the most recent run)')
+        .option('--artifacts-dir <dir>', `artifacts directory (default: ${DEFAULT_ARTIFACTS_DIR})`)
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const run = findRun(ctx, opts);
+        const failures = listVisualFailures(run.dir);
+        const abs = (p) => (p ? resolvePath(run.dir, p) : undefined);
+        if (ctx.opts.json)
+            return json({
+                runId: run.runId,
+                failures: failures.map((f) => ({
+                    ...f,
+                    actual: abs(f.actual),
+                    expected: abs(f.expected),
+                    diff: abs(f.diff),
+                })),
+            });
+        if (!failures.length) {
+            ok(`No failed visual checks in run ${run.runId}.`);
+            return;
+        }
+        heading(`${failures.length} failed visual check(s) in run ${run.runId}`);
+        const rel = (p) => (p ? relative(ctx.rootDir, p) : '—');
+        for (const f of failures) {
+            out('');
+            out(`${pc.bold(`${f.runnerProject}/${f.name}`)}  ${pc.dim(f.platform)}  ${reasonLabel(f)}`);
+            out(`  scenario  ${f.scenarioName} ${pc.dim(`(${f.featureUri})`)}`);
+            out(`  baseline  ${f.baseline}`);
+            table([
+                { image: 'expected', path: rel(abs(f.expected)) },
+                { image: 'actual', path: rel(abs(f.actual)) },
+                { image: 'diff', path: rel(abs(f.diff)) },
+            ]);
+        }
+        out('');
+        out(pc.dim(`Accept after reviewing the diff: sdods baselines accept <name…> --run ${run.runId}  (or --all)`));
+    });
+    baselines
+        .command('accept [names...]')
+        .description('Copy the actual screenshot of failed visual checks over their baselines (writes to the project tree)')
+        .requiredOption('--run <id>', 'run id the screenshots come from (required)')
+        .option('--all', 'accept every failed visual check of the run')
+        .option('--artifacts-dir <dir>', `artifacts directory (default: ${DEFAULT_ARTIFACTS_DIR})`)
+        .action(async (names, opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (opts.all && names.length)
+            throw new SdodsError('CONFIG_INVALID', 'Pass baseline names or --all, not both.', {
+                exitCode: 2,
+            });
+        const run = findRun(ctx, opts);
+        const failures = listVisualFailures(run.dir);
+        if (!failures.length)
+            throw new SdodsError('CONFIG_NOT_FOUND', `No failed visual checks in run ${run.runId}.`, {
+                hint: 'Nothing to accept. `sdods baselines diff --run <id>` lists what failed.',
+                exitCode: 2,
+            });
+        const picked = selectVisualFailures(failures, { names, all: opts.all });
+        const accepted = acceptVisualFailures({
+            runDir: run.dir,
+            failures: picked,
+            projectRoot: (slug) => ctx.registry.rootOf(slug),
+        });
+        if (ctx.opts.json)
+            return json({ runId: run.runId, accepted });
+        for (const a of accepted) {
+            ok(`${a.created ? 'created' : 'updated'} ${relative(ctx.rootDir, a.to)}  ${pc.dim(`${a.runnerProject}/${a.name} · ${a.platform} · ${reasonLabel(a)}`)}`);
+            out(pc.dim(`  from ${relative(ctx.rootDir, a.from)}`));
+            if (a.diff)
+                out(pc.dim(`  diff ${relative(ctx.rootDir, a.diff)}`));
+        }
+        out(pc.dim('Review the PNGs with `git diff --stat` and commit them with the change that moved the pixels.'));
+    });
+}
+function reasonLabel(f) {
+    if (f.reason === 'missing')
+        return pc.cyan('new baseline');
+    if (f.reason === 'size')
+        return pc.yellow('size changed');
+    return pc.yellow(`changed ${pct(f.diffRatio)}`.trim());
+}
+//# sourceMappingURL=baselines.js.map

package/dist/commands/doctor.js

@@ -2,17 +2,18 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { execa } from 'execa';
 import pc from 'picocolors';
-import { collectVarRefs, loadDotEnvLayer, loadEnvFile } from '@sdods/core';
+import { collectVarRefs, describeWorkers, effectiveWorkers, loadDotEnvLayer, loadEnvFile, poolAccountsByEnv, } from '@sdods/core';
 import { createContext } from '../context.js';
 import { browserStatuses } from './browsers.js';
 import { MIN_PLAYWRIGHT_FOR_STEP_RESULTS, installedPlaywrightVersion, stepResultsWarning, } from '../runner-compat.js';
-import { json, out } from '../ui.js';
+import { json, out, parseIntFlag } from '../ui.js';
 export function registerDoctorCommand(program) {
     program
         .command('doctor')
         .description('Check Node, Bun, browsers, projects, env vars and database reachability')
         .option('-p, --project <slug>', 'limit env-var checks to one project')
         .option('--fix', 'install missing browsers')
+        .option('-w, --workers <n>', 'worker count to check user pools against (default: SDODS_WORKERS, else Playwright default)', parseIntFlag('workers'))
         .action(async (opts, cmd) => {
         const ctx = createContext(cmd);
         const checks = [];
@@ -45,6 +46,8 @@ export function registerDoctorCommand(program) {
                 cwd: ctx.rootDir,
             }).catch(() => undefined);
         }
+        const envWorkers = Number(process.env.SDODS_WORKERS);
+        const workers = opts.workers ?? (Number.isInteger(envWorkers) && envWorkers > 0 ? envWorkers : undefined);
         const entries = opts.project
             ? [ctx.registry.entry(opts.project)]
             : ctx.registry.entriesList();
@@ -80,6 +83,9 @@ export function registerDoctorCommand(program) {
                         ? `Add ${missing.join(', ')} to ${join(e.root, `.env.${envName}`)}`
                         : undefined,
                 });
+                const pool = poolCheck(e.slug, envName, { ...e.config, root: e.root }, envCfg.users.poolSize, workers);
+                if (pool)
+                    checks.push(pool);
             }
         }
         const driver = process.env.DB_DRIVER ?? 'sqlite';
@@ -121,6 +127,42 @@ export function registerDoctorCommand(program) {
             process.exitCode = 1;
     });
 }
+/**
+ * #153: accounts per role in an exclusive, worker-held pool against the worker count. Advisory —
+ * doctor does not know which roles a run will select; `sdods run` makes the real decision and
+ * fails with USER_POOL_TOO_SMALL. Undefined when there is nothing to compare.
+ */
+function poolCheck(slug, envName, project, poolSize, workers) {
+    const pool = project.data.userPool;
+    if (!pool)
+        return undefined;
+    const name = `${slug}/${envName} user pool`;
+    if (pool.mode === 'shared' || pool.leaseScope === 'scenario') {
+        return {
+            name,
+            ok: true,
+            detail: pool.mode === 'shared' ? 'mode: shared (no leases)' : 'leaseScope: scenario (queues)',
+        };
+    }
+    const accounts = poolAccountsByEnv(project, {
+        envs: [envName],
+        poolSize: () => poolSize,
+    })?.get(envName);
+    if (!accounts)
+        return undefined; // not file-backed
+    const n = effectiveWorkers(workers);
+    const short = [...accounts].filter(([, count]) => count < n);
+    return {
+        name,
+        ok: short.length === 0,
+        optional: true,
+        detail: `${[...accounts].map(([role, count]) => `${role} ${count}`).join(', ') || 'no accounts'} ` +
+            `vs ${describeWorkers(workers)}`,
+        fix: short.length
+            ? `fewer accounts than workers for ${short.map(([r]) => r).join(', ')}: sdods run stops with USER_POOL_TOO_SMALL when more of their @user: scenarios could run at once than there are accounts. Set data.userPool.leaseScope: scenario, add accounts, or lower --workers.`
+            : undefined,
+    };
+}
 /**
  * The token matrix. "one-of" rows form a group: agents need ANY one of them.
  * Platform features never need an external token.

package/dist/commands/run.d.ts

@@ -40,6 +40,7 @@ export interface RunFlags {
     trigger?: string;
     allowEmpty?: boolean;
     notify?: boolean;
+    allowPoolContention?: boolean;
 }
 export declare function register(program: Command): void;
 export declare function runCommand(flags: RunFlags, cmd: Command): Promise<number>;

package/dist/commands/run.js

@@ -3,13 +3,13 @@ import { isAbsolute, join, relative, resolve as resolvePath } from 'node:path';
 import { execa } from 'execa';
 import pc from 'picocolors';
 import { RecordingModeSchema, newRunId, runFiles, } from '@sdods/contracts';
-import { SdodsError, CLI_OVERRIDES_ENV, VERSION, formatFindings, lintProject, listGeneratedProjects, moduleByName, moduleDir, normalizeTagExpr, parseTagExpr, redactRunTraces, serializeCliOverrides, setupTierOf, } from '@sdods/core';
+import { SdodsError, CLI_OVERRIDES_ENV, VERSION, checkPoolCapacity, collectGateEvidence, effectiveWorkers, evaluateGates, formatFindings, hasGates, lintProject, listGeneratedProjects, moduleByName, moduleDir, normalizeTagExpr, parseTagExpr, poolAccountsFor, poolDemandByRole, poolTooSmallError, redactRunTraces, serializeCliOverrides, setupTierOf, } from '@sdods/core';
 import { analyzeChangeImpact } from '@sdods/mcp';
 import { createContext } from '../context.js';
 import { browserStatuses } from './browsers.js';
 import { maybeNotify, notifyRun } from '../notify.js';
 import { installedPlaywrightVersion, stepResultsWarning } from '../runner-compat.js';
-import { collect, json, out, parseIntFlag, table, warn } from '../ui.js';
+import { collect, json, out, parseIntFlag, renderError, table, warn } from '../ui.js';
 const RECORDING_MODES = RecordingModeSchema.options.join(' | ');
 /** `--trace`/`--video` take Playwright's modes; refuse anything else before specs are generated. */
 function recordingMode(flag, value) {
@@ -37,6 +37,7 @@ function addRunOptions(cmd) {
         .option('--device <name>', 'device name for mobile emulation, e.g. "iPhone 15"')
         .option('--headed', 'run headed')
         .option('-w, --workers <n>', 'parallel workers', parseIntFlag('workers'))
+        .option('--allow-pool-contention', 'run even when a @user: role has fewer pool accounts than the workers that need it')
         .option('--shard <i/n>', 'shard, e.g. 1/3')
         .option('--retries <n>', 'retries per test', parseIntFlag('retries'))
         .option('--trace <mode>', `Playwright trace: ${RECORDING_MODES} (default: evidence.trace)`)
@@ -54,7 +55,7 @@ function addRunOptions(cmd) {
         .option('--har-update', 'record/refresh HAR files for @har scenarios')
         .option('--har-replay', 'replay HAR files for @har scenarios')
         .option('--strict', 'with --har-replay: abort on any request not in the HAR (offline)')
-        .option('--update-snapshots', 'update visual baselines')
+        .option('--update-snapshots', 'overwrite visual baselines without review (prefer `sdods baselines diff` / `accept`)')
         .option('--ui', 'interactive UI mode')
         .option('--debug', 'step debugger')
         .option('--list', 'list the run targets and tests that would run')
@@ -150,6 +151,9 @@ export async function runCommand(flags, cmd) {
     if (stepResults)
         warn(stepResults);
     const runId = flags.runId ?? newRunId();
+    if (flags.updateSnapshots)
+        warn('--update-snapshots overwrites every compared baseline without showing the diff. ' +
+            `Prefer a normal run, then \`sdods baselines diff --run ${runId}\` and \`sdods baselines accept <name> --run ${runId}\`.`);
     const cli = {
         env: envName,
         headed: flags.headed,
@@ -206,6 +210,59 @@ export async function runCommand(flags, cmd) {
         if (result.warnings.length && ctx.opts.verbose)
             process.stderr.write(formatFindings(result) + '\n');
     }
+    // --since selects features by git range; resolved here so the pool check counts the same selection.
+    const impact = flags.since
+        ? analyzeChangeImpact(cfg.project.root, ctx.rootDir, flags.since)
+        : undefined;
+    // #153: refuse, before generating anything, a run whose user pool cannot cover its workers.
+    // Listing runs nothing, and --ui / --debug run one scenario at a time by hand.
+    if (!flags.list && !flags.ui && !flags.debug) {
+        const poolCfg = cfg.project.data.userPool;
+        const accounts = poolCfg && poolCfg.mode !== 'shared' && poolCfg.leaseScope !== 'scenario'
+            ? poolAccountsFor(cfg)
+            : undefined;
+        if (accounts) {
+            const moduleRels = modules.map((m) => relative(cfg.project.root, moduleDir(cfg.project.root, moduleByName(projectCfg, m)))
+                .replace(/\\/g, '/')
+                .concat('/'));
+            const impactedRels = impact ? new Set(impact.impacted.map((r) => r.feature)) : undefined;
+            const grep = flags.grep ? safeRegExp(flags.grep) : undefined;
+            const features = cfg.env.vars?.features;
+            const demand = poolDemandByRole(cfg.project, cfg.env.name, {
+                layers: layers.length ? layers : projectCfg.layers,
+                browsers: browsers.length ? browsers : projectCfg.browsers,
+                tags,
+                setupTags: setup?.tags,
+                flags: typeof features === 'string'
+                    ? features
+                        .split(',')
+                        .map((f) => f.trim())
+                        .filter(Boolean)
+                    : undefined,
+                quarantine: process.env.SDODS_QUARANTINE === 'run' ? 'run' : 'skip',
+                fullyParallel: proc?.fullyParallel ?? projectCfg.fullyParallel,
+                includeFeature: (rel) => (!featureRel || rel === featureRel) &&
+                    (!moduleRels.length || moduleRels.some((m) => rel.startsWith(m))) &&
+                    (!impactedRels || impactedRels.has(rel)),
+                includeScenario: (name) => (!flags.scenario || name.includes(flags.scenario)) &&
+                    (!flags.grep || (grep?.test(name) ?? false)),
+                repeatEach: flags.repeatEach,
+                shardTotal: cfg.runtime.shard?.total,
+            });
+            const shortfalls = checkPoolCapacity({
+                pool: poolCfg,
+                accounts,
+                demand,
+                workers: effectiveWorkers(cfg.runtime.workers),
+            });
+            if (shortfalls.length) {
+                const error = poolTooSmallError(cfg, shortfalls, cfg.runtime.workers);
+                if (!flags.allowPoolContention)
+                    throw error;
+                warn(`${error.message} Running anyway (--allow-pool-contention).`);
+            }
+        }
+    }
     const selection = {
         project: entry.slug,
         env: cfg.env.name,
@@ -318,8 +375,7 @@ export async function runCommand(flags, cmd) {
     // `analyzeChangeImpact` has existed for a while and was reachable only
     // through MCP, so it could advise a human and could not select a run. This is
     // the seam that was missing; the mapping itself is unchanged.
-    if (flags.since) {
-        const impact = analyzeChangeImpact(cfg.project.root, ctx.rootDir, flags.since);
+    if (flags.since && impact) {
         if (impact.impacted.length === 0) {
             // Deliberately NOT "run everything" and deliberately not a silent empty
             // run. A run that registered zero scenarios exits 0 and looks identical
@@ -389,6 +445,29 @@ export async function runCommand(flags, cmd) {
             warn(`trace redaction failed for ${relative(ctx.rootDir, e.file)}: ${e.error}`);
     }
     const summary = readSummary(runDir, runId, exitCode, Date.now() - started);
+    // Process gates are judged here, from the run that just finished, before anything publishes it.
+    // One shard of several holds only part of the run, so its pass rate and its a11y/perf evidence
+    // are not the run's; a sharded process is gated where the shards are merged, not per shard.
+    const shardTotal = cfg.runtime.shard?.total ?? 1;
+    let gates;
+    if (proc && hasGates(proc.gates) && exitCode !== 130) {
+        if (shardTotal > 1) {
+            warn(`process "${proc.name}" gates are not evaluated on shard ${cfg.runtime.shard?.current}/${shardTotal}: one shard is not the whole run.`);
+        }
+        else {
+            gates = evaluateGates({
+                process: proc.name,
+                gates: proc.gates,
+                totals: summary?.totals,
+                evidence: collectGateEvidence(runDir),
+            });
+            writeFileSync(join(runDir, runFiles.gates), JSON.stringify(gates, null, 2));
+            if (summary)
+                summary.gates = gates;
+            manifest.gatesPassed = gates.passed;
+            writeManifest();
+        }
+    }
     if (summary)
         writeFileSync(join(runDir, runFiles.summary), JSON.stringify(summary, null, 2));
     const dbConfigured = process.env.DB_DRIVER === 'postgres'
@@ -428,6 +507,13 @@ export async function runCommand(flags, cmd) {
             writeManifest();
         }
     }
+    // A breached gate fails a run whose scenarios passed. Exit 1, as the exit-code reference says:
+    // a gate not met is a failure, not a configuration error.
+    if (gates && !gates.passed && finalExit === 0) {
+        finalExit = 1;
+        manifest.exitCode = finalExit;
+        writeManifest();
+    }
     // Enabled integrations (check runs, PR comment, issues) act on the run here, the same way
     // `sdods integrations notify --run-id` does. Failures are reported and never change the exit code.
     const notify = await maybeNotify({
@@ -461,9 +547,20 @@ export async function runCommand(flags, cmd) {
         out(pc.dim(`integrations: not notified (${notify.reason})`));
     }
     if (ctx.opts.json) {
-        json({ runId, runDir, exitCode: finalExit, summary, manifest, notify });
+        json({ runId, runDir, exitCode: finalExit, summary, manifest, notify, gates });
     }
     else {
+        if (gates) {
+            out('');
+            out(pc.bold(`gates · process ${gates.process}`));
+            table(gates.rows.map((r) => ({
+                gate: r.gate,
+                threshold: r.threshold,
+                actual: r.actual,
+                result: r.passed ? 'pass' : 'FAIL',
+                detail: r.detail ?? '',
+            })));
+        }
         const t = summary?.totals;
         out('');
         out(`${finalExit === 0 ? pc.green('✔ passed') : finalExit === 130 ? pc.yellow('■ cancelled') : finalExit === 2 ? pc.yellow('■ nothing ran') : pc.red('✖ failed')}  ${t ? `${t.passed} passed, ${t.failed} failed, ${t.skipped} skipped, ${t.flaky} flaky` : ''}  ${pc.dim(`(${Math.round((Date.now() - started) / 1000)}s)`)}`);
@@ -471,6 +568,13 @@ export async function runCommand(flags, cmd) {
         out(pc.dim(`html report: ${join(runDir, runFiles.htmlReport, 'index.html')}`));
         out(pc.dim(`dashboard:   ${join(runDir, runFiles.dashboard, 'index.html')}`));
     }
+    if (gates && !gates.passed) {
+        const failed = gates.rows.filter((r) => !r.passed);
+        renderError(new SdodsError('GATE_FAILED', `Process "${gates.process}" did not meet ${failed.length} gate(s): ${failed.map((r) => `${r.gate} (${r.actual}, needs ${r.threshold})`).join('; ')}.`, {
+            hint: `The verdict is in ${join(runDir, runFiles.gates)}. Gates are set under processes[].gates in sdods.project.yaml.`,
+            docsPath: '/docs/guides/processes-and-testing-types',
+        }), Boolean(ctx.opts.json));
+    }
     return finalExit;
 }
 /**
@@ -496,6 +600,15 @@ function projectFeaturePath(projectRoot, repoRoot, input) {
         });
     return rel;
 }
+/** `--grep` as the pool check reads it; a pattern Playwright would reject matches no scenario. */
+function safeRegExp(pattern) {
+    try {
+        return new RegExp(pattern);
+    }
+    catch {
+        return undefined;
+    }
+}
 function escapeRe(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/dist/program.js

@@ -24,6 +24,7 @@ import { register as registerCoverage } from './commands/coverage.js';
 import { register as registerBrowsers } from './commands/browsers.js';
 import { register as registerWatch } from './commands/watch.js';
 import { register as registerTrace } from './commands/trace.js';
+import { register as registerBaselines } from './commands/baselines.js';
 import { register as registerAgent } from './commands/agent.js';
 import { register as registerProposals } from './commands/proposals.js';
 import { register as registerMcp } from './commands/mcp.js';
@@ -80,6 +81,7 @@ export function buildProgram() {
     registerBrowsers(program);
     registerWatch(program);
     registerTrace(program);
+    registerBaselines(program);
     registerAgent(program);
     registerProposals(program);
     registerMcp(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "SDODS command line: run, record, analyze, agents, MCP server, scheduler and the web server.",
   "license": "Apache-2.0",
   "author": "SDODS <admin@sdods.com>",
@@ -24,8 +24,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.8.0",
-    "@sdods/core": "0.8.0",
+    "@sdods/contracts": "0.9.0",
+    "@sdods/core": "0.9.0",
     "commander": "^15.0.0",
     "execa": "^10.0.1",
     "picocolors": "^1.1.1",
@@ -34,12 +34,12 @@
     "zod": "^4.5.4",
     "@playwright/test": "^1.63.0",
     "playwright-core": "^1.63.0",
-    "@sdods/integrations": "0.8.0",
-    "@sdods/mcp": "0.8.0",
-    "@sdods/agents": "0.8.0",
-    "@sdods/db": "0.8.0",
+    "@sdods/integrations": "0.9.0",
+    "@sdods/mcp": "0.9.0",
+    "@sdods/agents": "0.9.0",
+    "@sdods/db": "0.9.0",
     "csv-parse": "^7.0.2",
-    "@sdods/server": "0.8.0"
+    "@sdods/server": "0.9.0"
   },
   "homepage": "https://sdods.com",
   "bugs": {

package/templates/projects/demo-shop/features/auth/user-pool.feature

@@ -1,6 +1,6 @@
 @ui @auth @pool
 Feature: User pool
-  Accounts are leased per worker from the pool dataset; login state is cached as storageState.
+  Accounts are leased per scenario from the pool dataset; login state is cached as storageState.
 
   @sanity @user:standard
   Scenario: A leased standard user starts logged in through cached storage state

package/templates/projects/demo-shop/features/cart/performance.feature

@@ -0,0 +1,14 @@
+@ui @cart @perf
+Feature: Cart performance
+  The @perf tag records the vitals of every document the scenario loads and judges them against
+  perf.budgets (pageLoadMs and lcpMs from the project, pageLoadMs overridden in envs/staging.yaml).
+
+  # WebKit does not implement largest-contentful-paint, and a vital a budget applies to that never
+  # fired fails the scenario rather than passing it, so this runs on Chromium and Firefox only.
+  @regression @skip:webkit
+  Scenario: The login and cart pages load within their budgets
+    Given I am on the login page
+    When I login with "standard_user" and "{{standardPassword}}"
+    And I add "{{defaultProduct}}" to the cart
+    And I navigate to the "cart" page
+    Then the cart should list "{{defaultProduct}}"

package/templates/projects/demo-shop/features/inventory/accessibility.feature

@@ -0,0 +1,12 @@
+@ui @inventory @a11y
+Feature: Inventory accessibility
+  The @a11y tag audits the page each scenario ends on with axe (WCAG 2.x A and AA) and fails on
+  anything at or above a11y.failOn (serious by default). SauceDemo's login, inventory and cart
+  pages have no WCAG A/AA violation axe can detect, so nothing is scoped out with include/exclude.
+
+  @regression
+  Scenario: The inventory page has no serious accessibility violations
+    Given I am on the login page
+    When I login with "standard_user" and "{{standardPassword}}"
+    Then I should be on the inventory page
+    And there should be 6 products listed

package/templates/projects/demo-shop/features/inventory/visual.feature

@@ -1,6 +1,7 @@
 @ui @inventory @visual
 Feature: Inventory visual baseline
-  Pixel comparison against a per-browser baseline (run once with --update-snapshots).
+  Pixel comparison against a per-browser, per-platform baseline. Review a failure with
+  `sdods baselines diff` and accept it with `sdods baselines accept inventory --run <id>`.
 
   @regression
   Scenario: Inventory page matches its baseline

package/templates/projects/demo-shop/sdods.project.yaml

@@ -101,6 +101,9 @@ data:
     roleColumn: role
     leaseStore: file
     leaseTtlMs: 600000
+    # One account per role after poolSize, and `release:check:live` runs three browsers in one
+    # invocation: release each account when its scenario ends so the browsers queue for it (#153).
+    leaseScope: scenario
 
 auth:
   strategy: form