waygraph 0.15.54 → 0.16.1

package/dist/cli/commands/codemod-checkpoints.js

@@ -0,0 +1,186 @@
+// `waygraph upgrade --codemod checkpoints`: rewrites a project from tag strings and `<In, Out>` type arguments to
+// Checkpoint values (`export const Home = checkpoint("Home")`, `checkpoint: Home`, `from: Home, to: ItemInCart`). Works
+// on the TypeScript AST (ts-morph), so formatting, comments and odd line breaks don't fool it.
+import { readFileSync, writeFileSync } from "node:fs";
+import { relative } from "node:path";
+import { IndentationText, Node, Project, SyntaxKind } from "ts-morph";
+import { walkDir } from "../../manifest/scan.js";
+function parse(text) {
+    const indentationText = /\n\t/.test(text) ? IndentationText.Tab : /\n {4}\S/.test(text) && !/\n {2}\S/.test(text) ? IndentationText.FourSpaces : IndentationText.TwoSpaces;
+    return new Project({ useInMemoryFileSystem: true, manipulationSettings: { indentationText } }).createSourceFile("/file.ts", text);
+}
+/** Whether `name` is still used anywhere outside import statements. */
+function usedOutsideImports(sf, name) {
+    return sf.getDescendantsOfKind(SyntaxKind.Identifier).some((id) => {
+        if (id.getText() !== name || id.getFirstAncestorByKind(SyntaxKind.ImportDeclaration))
+            return false;
+        const parent = id.getParent();
+        return !(Node.isPropertyAccessExpression(parent) && parent.getNameNode() === id) && !(Node.isPropertyAssignment(parent) && parent.getNameNode() === id);
+    });
+}
+/** Drops a named import from "waygraph" that nothing uses any more (and the import, when it ends up empty). */
+function dropUnusedWaygraphImport(sf, name) {
+    if (usedOutsideImports(sf, name))
+        return;
+    for (const imp of sf.getImportDeclarations().filter((d) => d.getModuleSpecifierValue() === "waygraph")) {
+        imp.getNamedImports().find((n) => n.getName() === name)?.remove();
+        if (imp.getNamedImports().length === 0 && !imp.getDefaultImport() && !imp.getNamespaceImport())
+            imp.remove();
+    }
+}
+/** Learns Checkpoint declarations already in value form, so the codemod can run again after a partial run. */
+function learnValues(sf, info) {
+    for (const decl of sf.getVariableDeclarations()) {
+        const init = decl.getInitializer();
+        if (Node.isCallExpression(init) && init.getExpression().getText() === "checkpoint") {
+            const tag = init.getArguments()[0];
+            if (Node.isStringLiteral(tag))
+                info.tags.set(decl.getName(), tag.getLiteralValue());
+        }
+        else if (Node.isAsExpression(init) && Node.isArrayLiteralExpression(init.getExpression())) {
+            info.unions.set(decl.getName(), init.getExpression().asKindOrThrow(SyntaxKind.ArrayLiteralExpression).getElements().map((e) => e.getText()));
+        }
+    }
+}
+/** Rewrites one states file; returns the new text and what it declared. */
+export function convertStates(text, info) {
+    const sf = parse(text);
+    learnValues(sf, info);
+    let changed = false;
+    for (const alias of sf.getTypeAliases()) {
+        if (!alias.isExported())
+            continue;
+        const name = alias.getName();
+        const type = alias.getTypeNodeOrThrow();
+        if (Node.isTypeReference(type) && type.getTypeName().getText() === "Checkpoint") {
+            const arg = type.getTypeArguments()[0];
+            if (!Node.isLiteralTypeNode(arg) || !Node.isStringLiteral(arg.getLiteral()))
+                continue;
+            const tag = arg.getLiteral().asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+            info.tags.set(name, tag);
+            alias.replaceWithText(`export const ${name} = checkpoint("${tag}");\nexport type ${name} = typeof ${name};`);
+            changed = true;
+        }
+        else if (Node.isUnionTypeNode(type)) {
+            const names = type.getTypeNodes().map((t) => t.getText());
+            if (!names.every((n) => info.tags.has(n) || info.unions.has(n)))
+                continue;
+            const flat = names.flatMap((n) => info.unions.get(n) ?? [n]);
+            info.unions.set(name, flat);
+            alias.replaceWithText(`export const ${name} = [${flat.join(", ")}] as const;\nexport type ${name} = (typeof ${name})[number];`);
+            changed = true;
+        }
+    }
+    if (!changed)
+        return text;
+    // `checkpoint` is now used as a value; `Checkpoint` stays only while something still names the type.
+    const wg = sf.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === "waygraph");
+    if (!wg)
+        sf.insertImportDeclaration(0, { moduleSpecifier: "waygraph", namedImports: ["checkpoint"] });
+    else if (wg.isTypeOnly())
+        sf.insertImportDeclaration(wg.getChildIndex(), { moduleSpecifier: "waygraph", namedImports: ["checkpoint"] });
+    else if (!wg.getNamedImports().some((n) => n.getName() === "checkpoint"))
+        wg.addNamedImport("checkpoint");
+    dropUnusedWaygraphImport(sf, "Checkpoint");
+    return sf.getFullText();
+}
+const SINGLE_CHECKPOINT = ["defineNavBlock", "defineNavClickBlock", "defineMemNavBlock", "definePageBlock", "defineAssertBlock"];
+const ROUTED = ["defineMethodBlock", "defineEffectBlock"];
+function optionsOf(call) {
+    const arg = call.getArguments()[0];
+    return Node.isObjectLiteralExpression(arg) ? arg : undefined;
+}
+/** `checkpoint: "Home"` with `<Home>` becomes `checkpoint: Home`. */
+function convertSingle(call, fn, info, skipped) {
+    const typeArg = call.getTypeArguments()[0];
+    const prop = optionsOf(call)?.getProperty("checkpoint");
+    const value = Node.isPropertyAssignment(prop) ? prop.getInitializer() : undefined;
+    if (!typeArg || !Node.isPropertyAssignment(prop) || !Node.isStringLiteral(value))
+        return;
+    const name = typeArg.getText();
+    if (info.tags.get(name) !== value.getLiteralValue()) {
+        skipped.push(`${fn}<${name}>`);
+        return;
+    }
+    call.removeTypeArgument(typeArg);
+    prop.setInitializer(name);
+}
+/** `<In, Out>` becomes `from: In, to: Out` (right after the name and description); a resolve that only returns `to` goes. */
+function convertRouted(call, fn, info, skipped) {
+    const [fromArg, toArg] = call.getTypeArguments();
+    const options = optionsOf(call);
+    if (!fromArg || !toArg || !options)
+        return;
+    const from = fromArg.getText();
+    const to = toArg.getText();
+    const known = (n) => info.tags.has(n) || info.unions.has(n);
+    const anywhere = from === "Checkpoint<string>";
+    if ((!anywhere && !known(from)) || !known(to)) {
+        skipped.push(`${fn}<${from}, ${to}>`);
+        return;
+    }
+    call.removeTypeArgument(toArg);
+    call.removeTypeArgument(fromArg);
+    const props = options.getProperties();
+    const after = Math.max(...["name", "description"].map((n) => props.findIndex((p) => Node.isPropertyAssignment(p) && p.getName() === n)));
+    options.insertPropertyAssignments(after + 1, [...(anywhere ? [] : [{ name: "from", initializer: from }]), { name: "to", initializer: to }]);
+    const tag = info.tags.get(to);
+    const instruction = options.getProperty("instruction");
+    const body = Node.isPropertyAssignment(instruction) ? instruction.getInitializer() : undefined;
+    const resolve = Node.isObjectLiteralExpression(body) ? body.getProperty("resolve") : undefined;
+    if (tag && Node.isPropertyAssignment(resolve) && resolve.getInitializer()?.getText().replace(/\s/g, "") === `()=>checkpoint("${tag}")`)
+        resolve.remove();
+    // Inserting and removing properties leaves the object's indentation uneven; tidy just this call.
+    call.formatText({ indentSize: call.getSourceFile().getProject().manipulationSettings.getIndentationText().length, convertTabsToSpaces: !call.getSourceFile().getFullText().includes("\n\t") });
+}
+/** Rewrites one Block file. Calls whose Checkpoints are not plain declared names are left as they are. */
+export function convertBlocks(text, info) {
+    const sf = parse(text);
+    const skipped = [];
+    for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression).reverse()) {
+        if (call.wasForgotten())
+            continue;
+        const fn = call.getExpression().getText();
+        if (SINGLE_CHECKPOINT.includes(fn))
+            convertSingle(call, fn, info, skipped);
+        else if (ROUTED.includes(fn))
+            convertRouted(call, fn, info, skipped);
+    }
+    if (sf.getFullText() === text)
+        return { text, skipped };
+    dropUnusedWaygraphImport(sf, "Checkpoint");
+    dropUnusedWaygraphImport(sf, "checkpoint");
+    // Checkpoints are now used as values: import them as values.
+    const known = (n) => info.tags.has(n) || info.unions.has(n);
+    for (const imp of sf.getImportDeclarations()) {
+        if (imp.isTypeOnly() && /states/.test(imp.getModuleSpecifierValue()) && imp.getNamedImports().some((n) => known(n.getName())))
+            imp.setIsTypeOnly(false);
+    }
+    return { text: sf.getFullText(), skipped };
+}
+/** Runs the codemod over a project; returns the files changed and the calls it left alone. */
+export function codemodCheckpoints(projectDir) {
+    const info = { tags: new Map(), unions: new Map() };
+    const files = walkDir(projectDir, /\.ts$/).filter((f) => !f.endsWith(".d.ts"));
+    const states = files.filter((f) => /\.states\.ts$|[/\\]_states\.ts$/.test(f));
+    const changed = [];
+    const skipped = [];
+    for (const f of states) {
+        const before = readFileSync(f, "utf8");
+        const after = convertStates(before, info);
+        if (after !== before) {
+            writeFileSync(f, after);
+            changed.push(relative(projectDir, f));
+        }
+    }
+    for (const f of files.filter((x) => !states.includes(x))) {
+        const before = readFileSync(f, "utf8");
+        const { text, skipped: s } = convertBlocks(before, info);
+        skipped.push(...s.map((c) => `${relative(projectDir, f)}: ${c}`));
+        if (text !== before) {
+            writeFileSync(f, text);
+            changed.push(relative(projectDir, f));
+        }
+    }
+    return { changed, skipped };
+}

package/dist/cli/commands/codemod-flows.d.ts

@@ -0,0 +1,18 @@
+import { Project } from "ts-morph";
+import type { SourceFile } from "ts-morph";
+/** A Block's kind by the file and export it is declared in; undefined when it isn't a known Block. */
+export type KindOf = (file: string, exportName: string) => string | undefined;
+/** Rewrites the old flow forms in a project's source files; returns problems it left for a person. */
+export declare function convertFlows(project: Project, kindOf: KindOf): {
+    changed: SourceFile[];
+    problems: {
+        file: string;
+        line: number;
+        reason: string;
+    }[];
+};
+/** Runs the codemod over a project's TypeScript files, using its runtime scan for each Block's kind. */
+export declare function codemodFlows(projectDir: string): Promise<{
+    changed: string[];
+    problems: string[];
+}>;

package/dist/cli/commands/codemod-flows.js

@@ -0,0 +1,284 @@
+// `waygraph upgrade --codemod flows`: rewrites `defineFlow([start, ...Blocks, end], options)`, `chainFlow(...)` and the
+// flow wrappers (`withTitle`, `withMemStub`, `withSessionReset`, `withExpectedFailure`, `withDemoPace`,
+// `withHighlightStyle`, `withBlockPace`, `withStub*`) into `map()` chains. Works on the TypeScript AST (ts-morph); each
+// Block's kind (nav, method, assert, ...) comes from the project's own runtime scan, so it picks the right step method.
+// The same pass moves ctx stubs onto their one form (codemod-stubs.ts).
+import { existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import { Node, Project, SyntaxKind } from "ts-morph";
+import { scanProject } from "../../manifest/project.js";
+import { walkDir } from "../../manifest/scan.js";
+import { convertStubs } from "./codemod-stubs.js";
+const SETTINGS = {
+    withMemStub: () => "memStub: true",
+    withSessionReset: () => "sessionReset: true",
+    withExpectedFailure: (a) => `expectedFailure: ${a}`,
+    withDemoPace: (a) => `demoPace: ${a}`,
+    withHighlightStyle: (a) => `highlightStyle: ${a}`,
+};
+const STUBS = { withStubBefore: "stubBefore", withStubAfter: "stubAfter", withStubOnError: "stubOnError" };
+const REMOVED = new Set(["start", "end", "chainFlow", "withTitle", "withBlockPace", "withHighlightFixtures", ...Object.keys(SETTINGS), ...Object.keys(STUBS)]);
+const STEP = { nav: "gotoPage", page: "gotoPage", method: "method", effect: "method", api: "method", assert: "assert" };
+/** The Block identifier an element of a flow is built from: `X`, `X.stubBefore(...)`, `withVerify(X, ...)`. */
+function rootIdentifier(expr) {
+    if (Node.isIdentifier(expr))
+        return expr;
+    if (Node.isCallExpression(expr)) {
+        const callee = expr.getExpression();
+        if (Node.isPropertyAccessExpression(callee))
+            return rootIdentifier(callee.getExpression());
+        if (Node.isIdentifier(callee) && callee.getText() === "withVerify")
+            return expr.getArguments()[0] && rootIdentifier(expr.getArguments()[0]);
+    }
+    return undefined;
+}
+/** Where an identifier is declared: its file and exported name, following imports. */
+function declarationOf(id) {
+    let symbol = id.getSymbol();
+    if (!symbol)
+        return undefined;
+    if (symbol.isAlias())
+        symbol = symbol.getAliasedSymbol() ?? symbol;
+    const decl = symbol.getDeclarations()[0];
+    if (!decl)
+        return undefined;
+    return { file: decl.getSourceFile().getFilePath(), name: symbol.getName() };
+}
+/** `engine.map({...}).start()...end()`: the `.map(...)` call at the root of a chain, or undefined. */
+function mapCallOf(expr) {
+    let cur = expr;
+    while (Node.isCallExpression(cur)) {
+        const callee = cur.getExpression();
+        if (!Node.isPropertyAccessExpression(callee))
+            return undefined;
+        if (callee.getName() === "map")
+            return cur;
+        cur = callee.getExpression();
+    }
+    return undefined;
+}
+/** The first step call after `.map(...)`/`.start()` in a chain. */
+function firstStepOf(mapCall) {
+    let parent = mapCall.getParent();
+    while (parent && Node.isPropertyAccessExpression(parent)) {
+        const call = parent.getParent();
+        if (!call || !Node.isCallExpression(call))
+            return undefined;
+        if (parent.getName() !== "start")
+            return call;
+        parent = call.getParent();
+    }
+    return undefined;
+}
+function addSetting(mapCall, setting) {
+    const arg = mapCall.getArguments()[0];
+    if (arg && Node.isObjectLiteralExpression(arg)) {
+        const inner = arg.getText().slice(1, -1).trim().replace(/,$/, "");
+        arg.replaceWithText(`{ ${inner ? `${inner}, ` : ""}${setting} }`);
+    }
+    else if (!arg) {
+        mapCall.addArgument(`{ ${setting} }`);
+    }
+    else {
+        arg.replaceWithText(`{ ...${arg.getText()}, ${setting} }`);
+    }
+}
+function addTitle(step, title) {
+    const block = step.getArguments()[0];
+    if (block)
+        block.replaceWithText(titleStub(block.getText(), title, indentOf(step)));
+}
+/** `engine` when the file has one in scope, else the standalone `map` export (imported from waygraph). */
+function mapRoot(sf, needsMap) {
+    const hasEngine = sf.getImportDeclarations().some((d) => d.getNamedImports().some((n) => (n.getAliasNode()?.getText() ?? n.getName()) === "engine"))
+        || sf.getVariableDeclaration("engine") !== undefined;
+    if (hasEngine)
+        return "engine.map";
+    needsMap.add(sf);
+    return "map";
+}
+/** The indentation of the statement a node sits in, so a rewritten chain lines up with the code around it. */
+function indentOf(node) {
+    const statement = node.getFirstAncestor((a) => Node.isStatement(a) || Node.isSourceFile(a.getParentOrThrow())) ?? node;
+    return " ".repeat(statement.getIndentationLevel() * 2);
+}
+function titleStub(block, title, indent) {
+    return `${block}.stubBefore((ctx) => {\n${indent}    ctx.title(${title});\n${indent}  })`;
+}
+function chain(head, steps, indent) {
+    return [head, ...steps, ".end()"].join(`\n${indent}  `);
+}
+/** Rewrites one call if it is one of the old forms; returns a problem message when it can't. */
+function rewrite(call, kindOf, needsMap) {
+    const sf = call.getSourceFile();
+    const callee = call.getExpression();
+    const args = call.getArguments();
+    const name = Node.isIdentifier(callee) ? callee.getText() : undefined;
+    const indent = indentOf(call);
+    if (Node.isPropertyAccessExpression(callee) && callee.getName() === "defineFlow") {
+        const list = args[0];
+        if (!list || !Node.isArrayLiteralExpression(list))
+            return "defineFlow without an array literal";
+        const elements = list.getElements().filter((e) => e.getText() !== "start" && e.getText() !== "end");
+        const steps = [];
+        for (const el of elements) {
+            let block = el;
+            let opts = "";
+            if (Node.isCallExpression(el) && el.getExpression().getText() === "withBlockPace") {
+                block = el.getArguments()[0];
+                opts = `, { pace: ${el.getArguments()[1]?.getText()} }`;
+            }
+            const id = rootIdentifier(block);
+            const decl = id && declarationOf(id);
+            const kind = decl && kindOf(decl.file, decl.name);
+            const step = kind && STEP[kind];
+            if (!step)
+                return `${el.getText().split("\n")[0]} is not a Block from a define*Block factory (kind: ${kind ?? "unknown"}); map() can't take it - rebuild it with a factory or nest it with .flow()`;
+            const external = step === "gotoPage" && /[\\/]\(external\)[\\/]/.test(decl.file);
+            steps.push(`.${external ? "gotoExternal" : step}(${block.getText()}${opts})`);
+        }
+        const options = args[1];
+        let settings = "";
+        let title;
+        if (options) {
+            if (!Node.isObjectLiteralExpression(options))
+                return "defineFlow options that aren't an object literal";
+            const kept = [];
+            for (const p of options.getProperties()) {
+                if (Node.isPropertyAssignment(p) && p.getName() === "title")
+                    title = p.getInitializer().getText();
+                else
+                    kept.push(p.getText());
+            }
+            if (kept.length)
+                settings = `{ ${kept.join(", ")} }`;
+        }
+        if (title && steps[0])
+            steps[0] = steps[0].replace(/^(\.\w+\()(.*)\)$/s, (_all, head, block) => `${head}${titleStub(block, title, indent)})`);
+        call.replaceWithText(chain(`${callee.getExpression().getText()}.map(${settings})`, [".start()", ...steps], indent));
+        return "changed";
+    }
+    if (name === "chainFlow") {
+        call.replaceWithText(chain(`${mapRoot(sf, needsMap)}()`, [".start()", ...args.map((a) => `.flow(${a.getText()})`)], indent));
+        return "changed";
+    }
+    if (name && STUBS[name] && args.length === 2) {
+        call.replaceWithText(`${args[0].getText()}.${STUBS[name]}(${args[1].getText()})`);
+        return "changed";
+    }
+    if (name && (SETTINGS[name] || name === "withTitle") && args[0]) {
+        const flow = args[0];
+        const mapCall = mapCallOf(flow);
+        if (name === "withTitle") {
+            const first = mapCall && firstStepOf(mapCall);
+            if (!first)
+                return `withTitle(${flow.getText().split("\n")[0]}, …): name the flow with ctx.title(…) in a stub on its first step`;
+            addTitle(first, args[1].getText());
+        }
+        else if (mapCall) {
+            addSetting(mapCall, SETTINGS[name](args[1]?.getText()));
+        }
+        else {
+            call.replaceWithText(chain(`${mapRoot(sf, needsMap)}({ ${SETTINGS[name](args[1]?.getText())} })`, [".start()", `.flow(${flow.getText()})`], indent));
+            return "changed";
+        }
+        call.replaceWithText(flow.getText());
+        return "changed";
+    }
+    if (name === "withHighlightFixtures")
+        return "withHighlightFixtures: chain ctx stubs on each Block where the flow uses it (Block.stubAfter((ctx) => …))";
+    if (name === "withBlockPace")
+        return "withBlockPace outside a flow: use the step option .method(Block, { pace })";
+    if (Node.isPropertyAccessExpression(callee) && callee.getName() === "end" && args[0] && mapCallOf(call)) {
+        const options = args[0];
+        if (Node.isObjectLiteralExpression(options)) {
+            const mapCall = mapCallOf(call);
+            for (const p of options.getProperties())
+                addSetting(mapCall, p.getText());
+            options.replaceWithText("");
+            call.replaceWithText(call.getText().replace(/\.end\(\s*\)$/, ".end()"));
+            return "changed";
+        }
+    }
+    return undefined;
+}
+/** Rewrites the old flow forms in a project's source files; returns problems it left for a person. */
+export function convertFlows(project, kindOf) {
+    const changed = new Set();
+    const problems = [];
+    const needsMap = new Set();
+    for (const sf of project.getSourceFiles()) {
+        // One rewrite per pass, innermost calls first, so a wrapper sees the map() chain its argument became. Calls left
+        // for a person never change, so the final pass (nothing left to rewrite) lists each of them once.
+        const rewritten = new Set();
+        for (;;) {
+            let progressed = false;
+            const left = [];
+            for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression).reverse()) {
+                if (call.wasForgotten())
+                    continue;
+                const top = sf.getStatements().indexOf(call.getFirstAncestor((a) => a.getParent() === sf));
+                const result = rewrite(call, kindOf, needsMap);
+                if (result === "changed") {
+                    changed.add(sf);
+                    rewritten.add(top);
+                    progressed = true;
+                    break;
+                }
+                if (result)
+                    left.push({ file: sf.getFilePath(), line: call.getStartLineNumber(), reason: result });
+            }
+            if (!progressed) {
+                problems.push(...left.reverse());
+                break;
+            }
+        }
+        if (!changed.has(sf))
+            continue;
+        // Replacing nested calls leaves odd indentation behind; TypeScript's formatter tidies just the rewritten statements.
+        const statements = sf.getStatements();
+        for (const i of rewritten)
+            statements[i]?.formatText({ indentSize: 2, convertTabsToSpaces: true });
+        for (const imp of sf.getImportDeclarations()) {
+            if (imp.getModuleSpecifierValue() !== "waygraph")
+                continue;
+            for (const n of imp.getNamedImports()) {
+                const local = n.getAliasNode()?.getText() ?? n.getName();
+                const stillUsed = sf.getDescendantsOfKind(SyntaxKind.Identifier).some((i) => {
+                    const parent = i.getParent();
+                    if (i.getText() !== local || Node.isImportSpecifier(parent))
+                        return false;
+                    return !(Node.isPropertyAccessExpression(parent) && parent.getNameNode() === i);
+                });
+                if (REMOVED.has(n.getName()) && !stillUsed)
+                    n.remove();
+            }
+            if (needsMap.has(sf) && !imp.getNamedImports().some((n) => n.getName() === "map"))
+                imp.addNamedImport("map");
+            if (imp.getNamedImports().length === 0 && !imp.getDefaultImport() && !imp.getNamespaceImport())
+                imp.remove();
+        }
+    }
+    return { changed: [...changed], problems };
+}
+/** Runs the codemod over a project's TypeScript files, using its runtime scan for each Block's kind. */
+export async function codemodFlows(projectDir) {
+    const scan = await scanProject(projectDir, { flows: false, maps: false });
+    const kinds = new Map(scan.blocks.map((b) => [`${b.absFile}#${b.exportName}`, b.kind]));
+    // Compiler options from the project's tsconfig; files from walkDir, which skips node_modules, dist and .git.
+    const tsconfig = join(projectDir, "tsconfig.json");
+    const project = new Project({ ...(existsSync(tsconfig) ? { tsConfigFilePath: tsconfig } : {}), skipAddingFilesFromTsConfig: true });
+    for (const file of walkDir(projectDir, /\.ts$/))
+        if (!file.endsWith(".d.ts"))
+            project.addSourceFileAtPath(file);
+    const flows = convertFlows(project, (file, name) => kinds.get(`${file}#${name}`));
+    const stubs = convertStubs(project);
+    const changed = [...new Set([...flows.changed, ...stubs.changed])];
+    const problems = [...flows.problems, ...stubs.problems];
+    for (const sf of changed)
+        sf.saveSync();
+    return {
+        changed: changed.map((sf) => relative(projectDir, sf.getFilePath())),
+        problems: problems.map((p) => `${relative(projectDir, p.file)}:${p.line}: ${p.reason}`),
+    };
+}

package/dist/cli/commands/codemod-stubs.d.ts

@@ -0,0 +1,10 @@
+import type { Project, SourceFile } from "ts-morph";
+/** Rewrites the old stub forms in every file; returns the files it changed and the calls left for a person. */
+export declare function convertStubs(project: Project): {
+    changed: SourceFile[];
+    problems: {
+        file: string;
+        line: number;
+        reason: string;
+    }[];
+};