@turri-dev/cli 0.1.27 → 0.2.0

package/dist/regenerate/spec-map.js

@@ -1,17 +1,26 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { withParseCache } from "../plain/parser.js";
-import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS, } from "../plain/spec.js";
-import { configForSpec, conformanceSwitchedOn, readProjectConfig } from "../config.js";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, REQUIRED_FUNCTIONAL_SPECS, TEST_REQUIREMENTS, } from "../plain/spec.js";
+import { readProjectConfig, testDirOf } from "../config.js";
+import { testPlainFilesOf } from "../test-plain-files.js";
 import { STDLIB_ROOT } from "../plain/stdlib.js";
 import { conformanceDirFor } from "./conformance.js";
 import { chainSpec } from "./loop.js";
 import { modulesRoot, projectDirOf } from "./paths.js";
 import { HISTORY_DIR } from "./lineage.js";
-import { codeTree, marksRegenerateAgain, readRecord, RECORD_FILE } from "./records.js";
+import { codeTree, hasScenarios, marksRegenerateAgain, readRecord, RECORD_FILE } from "./records.js";
+import { pureRenames } from "./renames.js";
 import { specFilesOf } from "./regenerate.js";
 import { builtTips, resolveRequiresChain } from "./requires.js";
 import { changesBetween, layoutOf, serializeTree } from "./spec-steps.js";
+import { SCRIPTS_DIR } from "./test-scripts.js";
+import { testingGap } from "./testing-steps.js";
+const NO_SCENARIOS = { conformance: [], acceptance: [] };
+/** Whether a functional spec has scenarios - and so conformance tests to write. */
+export function hasScenarioViews(scenarios) {
+    return scenarios.conformance.length + scenarios.acceptance.length > 0;
+}
 const itemsOf = (tree, heading) => (tree?.[heading] ?? []).slice();
 /** The sections an item of the code is in, as a page has them: a module below's functional specs among them. */
 const CODE_SECTIONS = [DEFINITIONS, NON_FUNCTIONAL_REQUIREMENTS, FUNCTIONAL_REQUIREMENTS];
@@ -37,6 +46,20 @@ function changesOf(before, after) {
     changesSeen.set(key, changes);
     return changes;
 }
+/** A functional spec's scenarios, as the map shows them. */
+function scenarioViews(item) {
+    const views = (list) => (list ?? []).map((scenario) => ({ id: scenario.id ?? "", text: scenario.text ?? "" }));
+    return { conformance: views(item[CONFORMANCE_TESTS]), acceptance: views(item[ACCEPTANCE_TESTS]) };
+}
+/** A functional spec's func-id, from its line in a serialized tree. */
+const idOf = (line) => {
+    try {
+        return JSON.parse(line ?? "").id;
+    }
+    catch {
+        return undefined;
+    }
+};
 const markdownOf = (line) => {
     try {
         return JSON.parse(line ?? "").markdown ?? "";
@@ -57,13 +80,8 @@ export function pageItems(input) {
     const before = serializeTree(moduleTree(input.record === null ? null : codeTree(input.record), input.module, input.own));
     const after = serializeTree(codeTree(now));
     const changes = changesOf(before, after);
-    // Each item's acceptance tests, by its line in the code's tree.
-    const acceptance = new Map();
-    for (const item of itemsOf(now, FUNCTIONAL_REQUIREMENTS)) {
-        const line = serializeTree(codeTree({ [FUNCTIONAL_REQUIREMENTS]: [item] })).split("\n").find((entry) => entry.startsWith("{"));
-        if (line !== undefined)
-            acceptance.set(line, (item[ACCEPTANCE_TESTS] ?? []).map((test) => test.markdown ?? ""));
-    }
+    // Each functional spec's scenarios now, by its func-id.
+    const scenariosNow = new Map(itemsOf(now, FUNCTIONAL_REQUIREMENTS).map((item) => [item.id ?? "", scenarioViews(item)]));
     // The record's lines, with what is added in front of each and what becomes of each: the spec's order, the ghosts in theirs.
     const lines = before.split("\n").slice(0, -1);
     const removedBy = new Map();
@@ -77,13 +95,15 @@ export function pageItems(input) {
     const items = [];
     const push = (section, state, line, wasLine) => {
         const text = markdownOf(line ?? wasLine);
+        const funcId = section === FUNCTIONAL_REQUIREMENTS ? idOf(line ?? wasLine) : undefined;
         items.push({
             key: "",
             section,
             state,
             text,
             ...(state === "changed" ? { was: markdownOf(wasLine) } : {}),
-            acceptance: line !== undefined ? (acceptance.get(line) ?? []) : [],
+            ...(funcId !== undefined ? { funcId } : {}),
+            scenarios: funcId !== undefined && line !== undefined ? (scenariosNow.get(funcId) ?? NO_SCENARIOS) : NO_SCENARIOS,
             ...(line !== undefined ? { line } : {}),
             ...(wasLine !== undefined ? { wasLine } : {}),
         });
@@ -111,33 +131,34 @@ export function pageItems(input) {
     const testReqs = new Set(itemsOf(input.tested ?? null, TEST_REQUIREMENTS).map((item) => item.markdown.trim()));
     if (input.own) {
         for (const item of itemsOf(input.spec, TEST_REQUIREMENTS)) {
-            items.push({ key: "", section: TEST_REQUIREMENTS, state: "test", text: item.markdown, acceptance: [], ...(testReqs.has(item.markdown.trim()) ? { tests: "now" } : {}) });
+            items.push({ key: "", section: TEST_REQUIREMENTS, state: "test", text: item.markdown, scenarios: NO_SCENARIOS, ...(testReqs.has(item.markdown.trim()) ? { tests: "now" } : {}) });
         }
     }
-    // Conformance tests: of the functional specs, those the tests record has as they read now, as they read before, or taken out.
-    // Tests marked to regenerate again were written against code since replaced: written for an earlier build, not now.
-    const testedItems = itemsOf(input.tested ?? null, FUNCTIONAL_REQUIREMENTS);
-    const tested = new Set(testedItems.filter((item) => !marksRegenerateAgain(item)).map((item) => item.markdown.trim()));
-    const replaced = new Set(testedItems.filter((item) => marksRegenerateAgain(item)).map((item) => item.markdown.trim()));
+    // Conformance tests: of the functional specs, by func-id, those the tests record has as they read now - their text and
+    // their scenarios - as they read before, or taken out. Tests marked to regenerate again were written against code since
+    // replaced: written for an earlier build, not now.
+    const testedItems = new Map(itemsOf(input.tested ?? null, FUNCTIONAL_REQUIREMENTS).map((item) => [item.id ?? "", item]));
+    const asNow = new Map(itemsOf(now, FUNCTIONAL_REQUIREMENTS).map((item) => [item.id ?? "", item]));
+    const reads = (item) => JSON.stringify({ markdown: item.markdown.trim(), scenarios: scenarioViews(item) });
     for (const item of items) {
-        if (item.section !== FUNCTIONAL_REQUIREMENTS || testedItems.length === 0)
+        if (item.section !== FUNCTIONAL_REQUIREMENTS || item.funcId === undefined)
             continue;
-        if (item.state === "removed") {
-            if (tested.has(item.text.trim()) || replaced.has(item.text.trim()))
-                item.tests = "removed";
-        }
-        else if (tested.has(item.text.trim()))
-            item.tests = "now";
-        else if (replaced.has(item.text.trim()) || (item.was !== undefined && (tested.has(item.was.trim()) || replaced.has(item.was.trim()))))
-            item.tests = "older";
+        const tested = testedItems.get(item.funcId);
+        if (tested === undefined)
+            continue;
+        const current = asNow.get(item.funcId);
+        if (item.state === "removed")
+            item.tests = "removed";
+        else
+            item.tests = !marksRegenerateAgain(tested) && current !== undefined && reads(tested) === reads(current) ? "now" : "older";
     }
     return keyed(items);
 }
-/** Each item's key: its section, whether it is a ghost, its text - and which of the same it is. */
+/** Each item's key: its section, whether it is a ghost, its text - a functional spec's func-id - and which of the same it is. */
 function keyed(items) {
     const seen = new Map();
     for (const item of items) {
-        const base = `${item.section}\n${item.state === "removed" ? "-" : "+"}${item.text.trim()}`;
+        const base = `${item.section}\n${item.state === "removed" ? "-" : "+"}${item.funcId !== undefined ? `# ${item.funcId}` : item.text.trim()}`;
         const count = seen.get(base) ?? 0;
         seen.set(base, count + 1);
         item.key = count === 0 ? base : `${base}\n${count}`;
@@ -201,7 +222,9 @@ const started = (entry) => {
 /** The files a module's page is read from: its spec files, its records, and its history - a commit moves the record read. */
 function depsOf(entry, codebase, testsDir) {
     const history = (dir) => [join(dirname(dir), HISTORY_DIR, "logs", "HEAD"), join(dir, RECORD_FILE)];
-    return [entry.plainFile, ...history(codebase.buildDir), ...history(testsDir), dirname(dirname(codebase.buildDir))];
+    // Its test plain files, and their folder: one added or taken out changes what the map reads.
+    const testPlain = [join(testDirOf(entry.plainFile), entry.moduleName), ...testPlainFilesOf(entry.plainFile)];
+    return [entry.plainFile, ...testPlain, ...history(codebase.buildDir), ...history(testsDir), dirname(dirname(codebase.buildDir))];
 }
 /** The chain a file's map reads: where its code lives - its furthest-built tip - or its own requires chain. */
 function chainOf(plainFile) {
@@ -258,7 +281,6 @@ export function readSpecMapWithDeps(files) {
                     imports: [],
                     items: [],
                     ...(entry.requires !== null ? { requires: entry.requires } : {}),
-                    conformance: conformanceOn(entry.plainFile),
                 };
                 const spec = specOf(home);
                 if (spec instanceof Error) {
@@ -266,14 +288,26 @@ export function readSpecMapWithDeps(files) {
                     return;
                 }
                 const projectDir = projectDirOf(entry.plainFile);
-                const record = home <= furthest ? readRecord(codebase.buildDir) : null;
-                const tested = readRecord(conformanceDirFor(entry.moduleName, modulesRoot(projectDir)));
+                // A pure rename not made yet is no work: shown as built, under its new func-id, with the one it is renamed from.
+                const renamed = home <= furthest ? pureRenames(readRecord(codebase.buildDir), readRecord(conformanceDirFor(codebase.moduleName, modulesRoot(projectDir))), spec, codebase.moduleName) : undefined;
+                const record = renamed?.code ?? null;
+                // What the conformance tests are written for, in the codebase that holds its code: the tip's suite holds the chain's.
+                const testsRecord = renamed?.tests ?? null;
+                const tested = testsRecord === null ? null : { ...testsRecord, [FUNCTIONAL_REQUIREMENTS]: moduleTree(testsRecord, entry.moduleName, home === at)[FUNCTIONAL_REQUIREMENTS] };
                 const paths = specFilesOf(entry.plainFile);
-                for (const path of [...paths, ...depsOf(entry, codebase, conformanceDirFor(entry.moduleName, modulesRoot(projectDir)))])
+                for (const path of [...paths, ...depsOf(entry, codebase, conformanceDirFor(codebase.moduleName, modulesRoot(projectDir)))])
                     deps.add(path);
                 const texts = paths.map((path, index) => ({ ...(index > 0 ? { label: importLabel(path, projectDir) } : {}), text: readText(path) }));
-                const items = pageItems({ module: entry.moduleName, own: home === at, spec, record, tested });
-                pages.push({ ...page, imports: texts.slice(1).map((text) => text.label), items: layOut(items, texts) });
+                const renamedFrom = new Map((renamed?.renames ?? []).flatMap((rename) => (rename.kind === "func-id" && rename.module === entry.moduleName ? [[rename.to, rename.from]] : [])));
+                const items = pageItems({ module: entry.moduleName, own: home === at, spec, record, tested }).map((item) => item.funcId !== undefined && renamedFrom.has(item.funcId) && item.state !== "removed" ? { ...item, renamedFrom: renamedFrom.get(item.funcId) } : item);
+                const own = home === at ? (spec[FUNCTIONAL_REQUIREMENTS] ?? []) : (spec[REQUIRED_FUNCTIONAL_SPECS] ?? []).filter((item) => item.module === entry.moduleName);
+                // Its scenarios untested for a step of adding tests skipped in the codebase that writes their tests: said on its row.
+                // Read again once a script is added to the project, or taken out.
+                if (own.some(hasScenarios))
+                    for (const path of [projectDir, join(projectDir, SCRIPTS_DIR)])
+                        deps.add(path);
+                const gap = own.some(hasScenarios) ? testingGap({ moduleName: codebase.moduleName, plainFile: codebase.plainFile, tree: spec, buildDir: codebase.buildDir }) : undefined;
+                pages.push({ ...page, conformance: own.some(hasScenarios), ...(gap !== undefined ? { testingMissing: gap.short } : {}), imports: texts.slice(1).map((text) => text.label), items: layOut(items, texts) });
             });
         }
         return pages;
@@ -294,15 +328,6 @@ function fingerprint(paths) {
     })
         .join("\n");
 }
-/** Whether a module's config has its conformance tests on: `conformance-tests:` is all (true) or chosen - off when not set. */
-function conformanceOn(plainFile) {
-    try {
-        return conformanceSwitchedOn(configForSpec(plainFile).conformanceTests);
-    }
-    catch {
-        return false;
-    }
-}
 function readText(path) {
     try {
         return readFileSync(path, "utf8");
@@ -318,7 +343,7 @@ function linesOf(pulse) {
     let seen = linesSeen.get(pulse);
     if (seen === undefined) {
         const set = (text) => new Set(text.split("\n").filter((line) => line.startsWith("{")));
-        // A conformance pulse's trees are the tests record's: its functional specs' lines - each with its number and acceptance tests.
+        // A conformance pulse's trees are the tests record's: its functional specs' lines - each with its func-id and scenarios.
         const specLines = (text, of = FUNCTIONAL_REQUIREMENTS) => {
             const out = [];
             let section = "";
@@ -336,25 +361,28 @@ function linesOf(pulse) {
             return new Set(specLines(pulse.after, TEST_REQUIREMENTS).filter((line) => !before.has(line)).map((line) => markdownOf(line).trim()));
         };
         const testing = () => {
-            // What it writes tests for: each functional spec whose line is new - its text, its acceptance tests or its number
-            // changed - by its text; none, and it is the definitions, reqs or test reqs that changed: it tests every one again.
+            // What it writes tests for: each functional spec whose line is new - its text or its scenarios changed - by its
+            // func-id; none, and it is the definitions, reqs or test reqs that changed: it tests every one again.
             const before = new Set(specLines(pulse.before));
             const after = specLines(pulse.after);
             const changed = after.filter((line) => !before.has(line));
-            return new Set((changed.length > 0 ? changed : after).map((line) => markdownOf(line).trim()));
+            return new Set((changed.length > 0 ? changed : after).map((line) => idOf(line) ?? ""));
         };
         seen = pulse.track === "code" ? { before: set(pulse.before), after: set(pulse.after), testing: new Set(), testReqs: new Set() } : { before: new Set(), after: new Set(), testing: testing(), testReqs: testReqs() };
         linesSeen.set(pulse, seen);
     }
     return seen;
 }
-/** A functional spec's first line, as a conformance pulse scheduled ahead of its code names it. */
-const headline = (text) => (text.trim().split("\n")[0] ?? "").replace(/^-\s*/, "").trim();
-/** Whether a conformance pulse writes tests for a functional spec: by its trees, or - scheduled, with none - by the specs it names. */
-function writesTestsFor(pulse, item) {
+/**
+ * Whether a conformance pulse writes tests for a functional spec, by its func-id: by its trees, or - following the code
+ * still to build, with none - by the functional specs it names, `module:func-id`.
+ */
+function writesTestsFor(pulse, item, module) {
+    if (item.funcId === undefined)
+        return false;
     if (pulse.specs !== undefined)
-        return pulse.specs.some((text) => headline(text) === headline(item.text));
-    return linesOf(pulse).testing.has(item.text.trim());
+        return pulse.specs.includes(`${module}:${item.funcId}`);
+    return linesOf(pulse).testing.has(item.funcId);
 }
 /** Whether a pulse regenerates an item: brings its line now, or takes out its line in the record. */
 function regenerates(pulse, item) {
@@ -383,6 +411,9 @@ function needsText(stuck) {
  * for in the running conformance pulse, planned in one, or not yet - none, where no conformance test is written at all.
  */
 function testReqMark(item, codebase, page) {
+    // No functional spec of the module has scenarios: nothing uses its test reqs.
+    if (page.conformance === false)
+        return { mark: "none", unused: true };
     if (item.tests === "now")
         return { mark: "built" };
     const text = item.text.trim();
@@ -409,16 +440,15 @@ export function markSpecMap(pages, plan) {
         const stuckPulse = codebase?.stuck?.pulse;
         const failed = stuckPulse !== undefined ? { number: stuckPulse.number, title: "", track: "code", running: false, rowId: "", before: stuckPulse.before, after: stuckPulse.after } : undefined;
         const conformance = codebase?.pulses.find((pulse) => pulse.running && pulse.track === "conformance");
-        // Test reqs only where conformance tests are on: the loop's word for it - the config, or asked for this session - else the config's.
-        const conformanceIsOn = codebase?.conformance ?? page.conformance !== false;
-        const items = page.items.filter((item) => item.state !== "test" || conformanceIsOn).map((item) => {
+        // Test reqs are always shown: where no functional spec has scenarios, as not used.
+        const items = page.items.map((item) => {
             const testing = conformance !== undefined && item.section === FUNCTIONAL_REQUIREMENTS && item.state !== "removed" && (() => {
-                return linesOf(conformance).testing.has(item.text.trim());
+                return item.funcId !== undefined && linesOf(conformance).testing.has(item.funcId);
             })();
             // Not being tested now: the conformance pulse planned to - its tests written for it as it reads now, or not.
             const testsPulse = testing || item.section !== FUNCTIONAL_REQUIREMENTS || item.state === "removed"
                 ? undefined
-                : codebase?.pulses.find((pulse) => !pulse.running && pulse.track === "conformance" && writesTestsFor(pulse, item));
+                : codebase?.pulses.find((pulse) => !pulse.running && pulse.track === "conformance" && writesTestsFor(pulse, item, page.module));
             const extra = testing ? { testing: true } : testsPulse !== undefined ? { testsPulse } : {};
             if (item.state === "test")
                 return { ...item, ...testReqMark(item, codebase, page), ...extra };
@@ -460,7 +490,9 @@ export function markSpecMap(pages, plan) {
                                 : differing === 0
                                     ? "all built"
                                     : (codebase.why ?? "waiting");
-        return { ...page, items, tracked: codebase !== undefined, ...(codebase !== undefined ? { codebase } : {}), status, stuck: codebase?.stuck !== undefined && running === undefined };
+        // A step of adding tests skipped: said after whatever else is happening, on the module's row.
+        const said = page.testingMissing !== undefined ? `${status} · ${page.testingMissing}` : status;
+        return { ...page, items, tracked: codebase !== undefined, ...(codebase !== undefined ? { codebase } : {}), status: said, stuck: codebase?.stuck !== undefined && running === undefined };
     });
 }
 /**

package/dist/regenerate/spec-steps.d.ts

@@ -1,13 +1,14 @@
-import { type MarshalledPlainSource } from "../plain/spec.ts";
+import { ACCEPTANCE_TESTS, CONFORMANCE_TESTS, type MarshalledPlainSource } from "../plain/spec.ts";
 /**
  * The steps from one spec to another: a sequence of spec diffs that, rendered one after the
  * other, take code built from the first spec to code built from the second.
  *
  * Both specs are marshalled trees, written out as text with one JSON value per line - a
  * section's name, then each of its items on a line of its own - and compared with git. So an
- * item is the unit of change: a functional spec with its acceptance tests and linked resources,
+ * item is the unit of change: a functional spec with its scenarios and linked resources,
  * a definition, a req. Git lines them up, so a spec inserted in the middle is one addition and
- * the specs after it are untouched, though their numbers moved.
+ * the specs after it are untouched. A functional spec is known by its func-id: one taken out and
+ * one put in with the same func-id are the same functional spec, changed - or, the same text, moved.
  *
  * The planner (`chunk-plan.ts`) cuts the changes into steps - which go together, which go first. It
  * picks changes by id; it never writes a diff. `makeStep` applies what it picked, and `inconsistencies`
@@ -63,10 +64,39 @@ export interface SpecChange {
 }
 /** The changes that take one serialized tree to another, in the order git lists them. */
 export declare function changesBetween(before: string, after: string): SpecChange[];
+/** Whether a change moves a functional spec and leaves what it says as it was. */
+export declare function isMove(change: SpecChange): boolean;
 /** How alike two items are: the share of their words they have in common. */
 export declare function similarity(a: string, b: string): number;
 /** A selection of changes, applied to the serialized tree they were found in. */
 export declare function applyChanges(before: string, changes: SpecChange[]): string;
+/** A functional spec's scenarios of one kind, as a person reads them: each under its scenario-id, in its section's tag. */
+export declare function scenarioLines(tag: string, scenarios: Array<{
+    id?: string;
+    text?: string;
+}> | undefined): string[];
+type ScenarioItem = {
+    id?: string;
+    text?: string;
+};
+type ScenarioCarrier = {
+    id?: string;
+    [CONFORMANCE_TESTS]?: ScenarioItem[];
+    [ACCEPTANCE_TESTS]?: ScenarioItem[];
+};
+/** A functional spec's test plain file, as it would read: its binding, then each section that has scenarios, each scenario under its id. */
+export declare function testPlainFileText(module: string, item: ScenarioCarrier): string;
+/** One file's two texts as git diffs them, named `path` on both sides: an empty side is the file added or taken out whole. */
+export declare function diffFileTexts(before: string, after: string, path: string): string;
+/** Where a functional spec's test plain file is, by its func-id and - a module below's - its module: the path a diff names it by. */
+export type TestPlainPath = (funcId: string, module?: string) => string;
+/**
+ * The functional specs' test plain files a change between two serialized trees touches, each as a diff of its own,
+ * rebuilt from the trees as the module's file is: only the trees that carry scenarios - the conformance tests' - have
+ * any. A functional spec that had no scenarios has no test plain file before, so its file shows as added whole; one whose
+ * scenarios all went, as deleted whole - an empty one is a syntax error.
+ */
+export declare function diffTestPlainFiles(before: string, after: string, module: string, pathOf: TestPlainPath): string;
 /** A serialized tree as a person reads it, section by section. */
 export declare function treeText(serialized: string): string;
 /** A change as the planning agent is shown it. */
@@ -107,7 +137,7 @@ export interface SpecLayout {
     sections: string[];
     /** Each concept's place in the file's definitions - the parser orders them by what uses what. */
     concepts: Map<string, number>;
-    /** The sections whose items the file writes with no blank line between them. */
+    /** The sections whose items the file writes with no blank line between them - definitions and reqs: functional specs never are. */
     tight: Set<string>;
 }
 export declare function layoutOf(text: string): SpecLayout;
@@ -122,6 +152,11 @@ export declare function layoutOf(text: string): SpecLayout;
 export declare function plainText(serialized: string, layout?: SpecLayout): string;
 /** git's diff of two serialized trees, as ***plain text - see plainText. */
 export declare function diffSpecText(before: string, after: string, file?: string, layout?: SpecLayout): string;
+/**
+ * The functional specs of the modules below that a change between two serialized trees touches, each module's as a diff
+ * of its own file's `***functional specs***`: the tip is built with them, but its own file does not hold them.
+ */
+export declare function diffRequiredSpecs(before: string, after: string, file?: string): string;
 /** The linked resources of a changed item whose content is different now - each hashed on its own: by their path, with both hashes. */
 export declare function resourcesChanged(before: string | undefined, after: string | undefined): Array<{
     target: string;
@@ -134,4 +169,12 @@ export declare function resourcesChanged(before: string | undefined, after: stri
  * held before - so the hunk says that it changed, and what it holds now is the file itself.
  */
 export declare function resourceDiff(changes: SpecChange[], file?: string): string;
-export declare function makeStep(title: string, reason: string, changes: SpecChange[], before: string, after: string, file: string, layout?: SpecLayout): SpecStep;
+/**
+ * A step of the work. `testPlain`: for the conformance tests' steps, the module and where its functional specs' test plain
+ * files are - a scenario changed shows as a diff of its test plain file, after the module's.
+ */
+export declare function makeStep(title: string, reason: string, changes: SpecChange[], before: string, after: string, file: string, layout?: SpecLayout, testPlain?: {
+    module: string;
+    pathOf: TestPlainPath;
+}): SpecStep;
+export {};