@popoverai/dotrequirements 0.33.0 → 0.34.0

package/dist/rehearsal/earlier.js

@@ -0,0 +1,138 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { parse } from "yaml";
+import { parseThing } from "../commands/solution/things.js";
+import { api } from "../convex.js";
+/**
+ * A new rehearsal replaces the earlier runs of its scenario (REHEARSE-6):
+ * the rehearsal solutions in the project recorded as runs of the same
+ * scenario file are removed before it starts, with what they made. What any scenario in the
+ * same folder names as an input stays, so that scenario can still start
+ * from it; so does an earlier run whose history a scenario there starts
+ * from (6.2.0), whole.
+ */
+/**
+ * What the scenarios in this scenario's folder name: the documents, boards
+ * and mockups they name as inputs, and the earlier rehearsals' solutions
+ * whose history they start from (REHEARSE-6.2.0), each by id, with the files
+ * that name it. Refuses when one of those files can't be read, since then
+ * what it names can't be known.
+ */
+export function namedInputs(scenarioPath) {
+    return namedInFolder(scenarioPath).inputs;
+}
+function namedInFolder(scenarioPath) {
+    const folder = dirname(resolve(scenarioPath));
+    const named = new Map();
+    const histories = new Map();
+    for (const name of readdirSync(folder).sort()) {
+        if (!name.endsWith(".yaml"))
+            continue;
+        let inputs;
+        try {
+            const file = parse(readFileSync(join(folder, name), "utf8"));
+            inputs = file?.inputs;
+            const source = file?.history?.solution;
+            if (typeof source === "string" && source.trim()) {
+                const id = source.trim();
+                histories.set(id, [...(histories.get(id) ?? []), name]);
+            }
+            for (const entries of Object.values((inputs ?? {}))) {
+                for (const entry of Array.isArray(entries) ? entries : []) {
+                    if (typeof entry !== "string")
+                        continue;
+                    const thing = parseThing(entry);
+                    const id = thing.kind === "document"
+                        ? thing.documentId
+                        : thing.kind === "board"
+                            ? thing.boardId
+                            : thing.kind === "mockup"
+                                ? thing.mockupId
+                                : null;
+                    if (id)
+                        named.set(id, [...(named.get(id) ?? []), name]);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Can't tell what ${name} names as its inputs, so no earlier run was removed: ${error instanceof Error ? error.message : String(error)} Fix it, or rehearse with --keep.`);
+        }
+    }
+    return { inputs: named, histories };
+}
+/**
+ * How long a rehearsal waits for an earlier run's branch to be deleted
+ * before it starts anyway: the deletion is the backend's, scheduled as the
+ * run is removed.
+ */
+const BRANCH_WAIT_MS = 60_000;
+/**
+ * Wait for the backend to delete an earlier run's branch (REHEARSE-6.7):
+ * it must be gone before the new run makes its own, or that one takes a
+ * suffixed name. What became of it, or pending when it took too long.
+ */
+async function branchOutcome(client, removalId, pause) {
+    const deadline = Date.now() + BRANCH_WAIT_MS;
+    for (;;) {
+        const removal = await client.query(api.solutions.branches.removal, { removalId });
+        if (!removal)
+            return null;
+        if (removal.outcome) {
+            return {
+                name: removal.branch,
+                outcome: removal.outcome,
+                ...(removal.why ? { why: removal.why } : {}),
+            };
+        }
+        if (Date.now() >= deadline) {
+            return { name: removal.branch, outcome: "pending" };
+        }
+        await pause(1000);
+    }
+}
+/**
+ * Remove the earlier runs of the scenario, keeping what a scenario names
+ * (REHEARSE-6.0, 6.2), and keeping whole an earlier run whose history a
+ * scenario starts from (6.2.0).
+ */
+export async function removeEarlierRuns(scenarioPath, client, pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+    const { inputs: named, histories } = namedInFolder(scenarioPath);
+    const scenario = basename(scenarioPath);
+    const earlier = await client.query(api.solutions.queries.rehearsalsOf, { project: client.project, scenario });
+    const kept = [];
+    const keptRuns = [];
+    const branches = [];
+    let removedRuns = 0;
+    for (const solutionId of earlier) {
+        const startFromIt = histories.get(solutionId);
+        if (startFromIt) {
+            keptRuns.push({ solutionId, namedBy: startFromIt });
+            continue;
+        }
+        removedRuns++;
+        const removed = await client.mutation(api.solutions.mutations.removeRehearsal, {
+            solutionId,
+            keep: [...named.keys()],
+        });
+        // Each of its branches, one per pull-request surface (SOLBRANCH-1.4).
+        for (const removalId of removed.branchRemovals ?? []) {
+            const branch = await branchOutcome(client, removalId, pause);
+            if (branch)
+                branches.push(branch);
+        }
+        for (const thing of removed.kept) {
+            kept.push({
+                reference: `${thing.kind}:${thing.id}`,
+                namedBy: thing.because === "named" ? (named.get(thing.id) ?? []) : [],
+            });
+        }
+    }
+    return {
+        scenario,
+        removed: removedRuns,
+        kept,
+        ...(keptRuns.length > 0 ? { keptRuns } : {}),
+        ...(branches.length > 0 ? { branches } : {}),
+    };
+}
+//# sourceMappingURL=earlier.js.map

package/dist/rehearsal/index.d.ts

@@ -0,0 +1,5 @@
+export { planForOutcomes, planOf } from "./derive.js";
+export { partiesOf, rehearse } from "./driver.js";
+export { renderReport } from "./report.js";
+export type * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rehearsal/index.js

@@ -0,0 +1,4 @@
+export { planForOutcomes, planOf } from "./derive.js";
+export { partiesOf, rehearse } from "./driver.js";
+export { renderReport } from "./report.js";
+//# sourceMappingURL=index.js.map

package/dist/rehearsal/live.d.ts

@@ -0,0 +1,72 @@
+import { solutionClient } from "../commands/solution/client.js";
+import type { Party, PersonScript, RehearsalClient, Scenario } from "./types.js";
+/**
+ * The live mode (REHEARSE-4): the driver over the CLI's client against the
+ * linked project. Scripted agents run through the same verbs an agent
+ * runs; real agents are the runner's, awaited; the person's decisions are
+ * answered from the scenario's own script, and the rehearsal stops only at
+ * a decision nobody scripted.
+ */
+/** The scenario as a file: plans and artifacts by name, scripts as data. */
+export type ScenarioFile = {
+    title: string;
+    /** What the person wrote about the solution beyond its title, as Markdown. */
+    description?: string;
+    /**
+     * "default" for the project's plan; a path to a plan file; or some of
+     * either's outcomes, run on their own: `{ from: default, outcomes: [Code,
+     * Demo] }`, or `outcome: Pitch` for one. `step` and `steps` are read as
+     * `outcome` and `outcomes`.
+     */
+    plan: "default" | string | {
+        from?: "default" | string;
+        outcome?: string;
+        outcomes?: string[];
+        step?: string;
+        steps?: string[];
+    };
+    /**
+     * The branch the solution's branch is made from, rather than the
+     * repository's default branch (REHEARSE-4.5): `branch: rehearsal-fixtures/spec`.
+     */
+    branch?: string;
+    /**
+     * An earlier rehearsal's solution and an outcome it made, whose history
+     * the solution starts with (REHEARSE-4.8):
+     * `history: { solution: q97fe7s7…, after: Code }`. Each input `inputs`
+     * doesn't name is taken from that solution as it stood when that outcome
+     * was made, with its thread.
+     */
+    history?: {
+        solution?: unknown;
+        after?: unknown;
+    };
+    /**
+     * Artifacts by input name: references; `image:<path>` for an image, its
+     * path from the scenario's folder, to upload first (REHEARSE-4.7); or
+     * { file } to publish first.
+     */
+    inputs?: Record<string, Array<string | {
+        file: string;
+        title?: string;
+    }>>;
+    /**
+     * By agent (`Code Reviewer`, `Pitch/drafter`), by an outcome's name (its
+     * drafter), by "<outcome>/reviewer" (its reviewers), or by
+     * "<outcome>/<agent>": "real", or a script as data (`Scenario.parties`).
+     */
+    parties?: Record<string, "real" | Omit<Party, "expect">>;
+    /** What the person answers, by an outcome's name or a checkpoint's, in order asked. */
+    person?: PersonScript;
+    /** Minutes to wait for a real agent. */
+    wait?: number;
+};
+/** The scenario file read into a scenario the driver runs. */
+export declare function scenarioFrom(path: string, client: ReturnType<typeof solutionClient>): Promise<Scenario>;
+/**
+ * The driver's client over the CLI: the project secret for every call. The
+ * solution is created as a rehearsal's, which is what lets that same secret
+ * answer the decisions the scenario scripted.
+ */
+export declare function liveClient(): RehearsalClient;
+//# sourceMappingURL=live.d.ts.map

package/dist/rehearsal/live.js

@@ -0,0 +1,301 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { webApiUrl } from "../cloud.js";
+import { solutionClient } from "../commands/solution/client.js";
+import { ACCEPTED_IMAGE_FORMATS, imageFormat, } from "../commands/solution/image.js";
+import { planPayload, readPlanFile } from "../commands/solution/plan-file.js";
+import { parseThing } from "../commands/solution/things.js";
+import { uploadToApp } from "../commands/solution/upload.js";
+import { api } from "../convex.js";
+import { publishToCloud } from "../sync/publish.js";
+import { getProjectCredentials } from "../utils/project-settings.js";
+async function planNamed(name, client, from) {
+    if (name === "default") {
+        const result = await client.query(api.solutions.queries.defaultPlan, { project: client.project });
+        return result.plan;
+    }
+    const spec = readPlanFile(readFileSync(resolve(from, name), "utf8"), name);
+    if (!spec?.plan)
+        throw new Error(`${name} has no plan in it.`);
+    // PLAN-1: the backend reads a plan as a file writes it.
+    return client.query(api.solutions.queries.readPlanFile, {
+        plan: planPayload(spec),
+    });
+}
+/**
+ * Artifacts named as files are published as documents first (REHEARSE-4.1),
+ * before the solution they are to belong to exists: the solution is created
+ * with them, and takes them as its own then (4.1.0). Whether one is a
+ * requirements document is its file's name, as at a push (SOLDOC-3). An
+ * image named by its path is uploaded first for the same reason, and kept
+ * on the input under its file name, as an image an agent submits is (4.7);
+ * `inputImages` read it beforehand.
+ */
+async function artifact(entry, from, client, images) {
+    if (typeof entry === "string") {
+        const image = images.get(entry);
+        if (!image)
+            return { thing: parseThing(entry) };
+        const storageId = await uploadToApp(client, api.solutions.images.inputUploadUrl, { project: client.project }, image);
+        return { thing: { kind: "image", storageId, name: image.name } };
+    }
+    const { projectId, projectSecret } = getProjectCredentials();
+    const markdownContent = readFileSync(resolve(from, entry.file), "utf8");
+    const { documentId } = await publishToCloud({
+        projectId,
+        projectSecret,
+        markdownContent,
+        title: entry.title,
+    });
+    return {
+        thing: { kind: "document", documentId },
+        published: {
+            documentId,
+            isRequirementsDoc: entry.file.endsWith(".requirements.md"),
+        },
+    };
+}
+/**
+ * The images a scenario names for its inputs as `image:<path>`, a path from
+ * the scenario's folder, each read and checked as `dotreq solution author`
+ * checks one (SIGHT-9.0.0) before anything is published, removed or
+ * created (REHEARSE-4.7). By the entry that names each.
+ */
+function inputImages(scenario, inputs, from) {
+    const images = new Map();
+    for (const entries of Object.values(inputs)) {
+        for (const entry of entries) {
+            if (typeof entry !== "string" || !entry.startsWith("image:"))
+                continue;
+            const path = entry.slice("image:".length);
+            const full = resolve(from, path);
+            if (!path || !existsSync(full) || !statSync(full).isFile()) {
+                throw new Error(`${scenario} names the image ${path || "(no path)"}, but there is no file there. Nothing was removed or created.`);
+            }
+            const bytes = new Uint8Array(readFileSync(full));
+            const format = imageFormat(bytes);
+            if ("refused" in format) {
+                throw new Error(`${scenario} names ${path} as an image, but it isn't one a browser can show (${format.refused}). Name ${ACCEPTED_IMAGE_FORMATS}. Nothing was removed or created.`);
+            }
+            images.set(entry, {
+                name: basename(full),
+                contentType: format.contentType,
+                bytes,
+            });
+        }
+    }
+    return images;
+}
+/**
+ * Refuse a scenario whose branch to start from the project's repository
+ * doesn't have (REHEARSE-4.6), before anything is published, removed or
+ * created. Asked of the app, which reads the repository with its own
+ * credential: a rehearsal runs from the project's connection sandbox,
+ * which has none.
+ */
+async function checkBranch(name, branch) {
+    const { projectId, projectSecret } = getProjectCredentials();
+    const base = webApiUrl();
+    const response = await fetch(`${base}/api/rehearsals/branch`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ projectId, projectSecret, branch }),
+    });
+    const said = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        throw new Error(`Couldn't find out whether the project's repository has the branch ${branch}, which ${name} starts from: ${said.error ?? `the app answered ${response.status}`}. Nothing was removed or created.`);
+    }
+    if (!said.repository) {
+        throw new Error(`${name} starts from the branch ${branch}, but the project has no repository to find it in. Nothing was removed or created.`);
+    }
+    if (!said.head) {
+        throw new Error(`${name} starts from the branch ${branch}, which ${said.repository} doesn't have. Nothing was removed or created.`);
+    }
+}
+/**
+ * The history a scenario starts from (REHEARSE-4.8), checked with the app
+ * before anything is published, removed or created (4.8.2): refused, saying
+ * which solution or outcome and why, when the solution isn't one of the
+ * project's rehearsals or hasn't made the outcome. What that solution
+ * holds, for the inputs the scenario leaves to it.
+ */
+async function startingHistory(name, history, client) {
+    const solution = typeof history.solution === "string" ? history.solution.trim() : "";
+    const after = typeof history.after === "string" ? history.after.trim() : "";
+    if (!solution || !after) {
+        throw new Error(`${name}'s history names ${solution ? "no outcome" : "no solution"}: write it as history: { solution: <the earlier rehearsal's solution>, after: <an outcome it made> }. Nothing was removed or created.`);
+    }
+    const said = await client.query(api.solutions.queries.rehearsalHistory, { project: client.project, solution, after });
+    if ("refused" in said) {
+        throw new Error(`${name} can't start from that history. ${said.refused} Nothing was removed or created.`);
+    }
+    return { solution, after, outcomes: said.outcomes };
+}
+/** The outcomes a scenario's part of a plan names: `outcomes`, or one `outcome`; `steps` and `step` read the same. */
+function outcomesNamed(path, part) {
+    const many = part.outcomes ?? part.steps;
+    const one = part.outcome ?? part.step;
+    const names = many ?? (one !== undefined ? [one] : []);
+    if (names.length === 0 || names.some((name) => typeof name !== "string")) {
+        throw new Error(`${path}'s plan names no outcomes to run: write it as plan: { from: default, outcomes: [<outcome>, ...] }.`);
+    }
+    return names;
+}
+/** The scenario file read into a scenario the driver runs. */
+export async function scenarioFrom(path, client) {
+    const file = readPlanFile(readFileSync(resolve(path), "utf8"), path);
+    const from = resolve(path, "..");
+    if (!file?.title || !file.plan) {
+        throw new Error(`${path} needs a title and a plan.`);
+    }
+    const branch = typeof file.branch === "string" ? file.branch.trim() : "";
+    if (file.branch !== undefined && !branch) {
+        throw new Error(`${path}'s branch names no branch: give the name of the branch the solution's branch is to be made from, or leave it out.`);
+    }
+    if (branch)
+        await checkBranch(basename(path), branch);
+    const history = file.history === undefined || file.history === null
+        ? undefined
+        : await startingHistory(basename(path), typeof file.history === "object" ? file.history : {}, client);
+    const plan = typeof file.plan === "string"
+        ? await planNamed(file.plan, client, from)
+        : {
+            from: await planNamed(file.plan.from ?? "default", client, from),
+            outcomes: outcomesNamed(path, file.plan),
+        };
+    const images = inputImages(basename(path), file.inputs ?? {}, from);
+    const inputs = {};
+    const published = [];
+    for (const [name, entries] of Object.entries(file.inputs ?? {})) {
+        inputs[name] = [];
+        for (const entry of entries) {
+            const made = await artifact(entry, from, client, images);
+            inputs[name].push(made.thing);
+            if (made.published)
+                published.push(made.published);
+        }
+    }
+    const parties = {};
+    for (const [key, party] of Object.entries(file.parties ?? {})) {
+        parties[key] = party === "real" ? "real" : party;
+    }
+    return {
+        title: file.title,
+        file: basename(path),
+        description: file.description,
+        plan,
+        inputs,
+        ...(published.length > 0 ? { published } : {}),
+        ...(branch ? { branch } : {}),
+        ...(history ? { history } : {}),
+        parties,
+        person: file.person,
+        waitMs: file.wait ? file.wait * 60_000 : undefined,
+    };
+}
+/**
+ * The driver's client over the CLI: the project secret for every call. The
+ * solution is created as a rehearsal's, which is what lets that same secret
+ * answer the decisions the scenario scripted.
+ */
+export function liveClient() {
+    const client = solutionClient();
+    return {
+        async create(args) {
+            return client.mutation(api.solutions.mutations.create, {
+                project: client.project,
+                title: args.title,
+                description: args.description,
+                plan: args.plan,
+                inputs: args.inputs,
+                rehearsal: true,
+                scenario: args.scenario,
+                baseBranch: args.branch,
+                published: args.published,
+                history: args.history,
+            });
+        },
+        async createScores(scores) {
+            const { scoresId } = await client.mutation(api.scores.mutations.create, { project: client.project, ...scores });
+            return scoresId;
+        },
+        async panel(solutionId) {
+            return client.query(api.solutions.queries.getPlan, { solutionId });
+        },
+        async next(args) {
+            return client.mutation(api.solutions.mutations.next, {
+                solutionId: args.solutionId,
+                agent: args.agent,
+            });
+        },
+        async complete(args) {
+            const said = await client.mutation(api.solutions.mutations.complete, {
+                solutionId: args.solutionId,
+                ...(args.agent !== undefined ? { agent: args.agent } : {}),
+                outcome: args.outcome,
+                made: args.made,
+                comment: args.comment,
+                summary: args.summary,
+                review: args.review,
+            });
+            // STEP-REVIEW-18.7.0: a result refused because the drafter submitted
+            // again is a refusal like any other to the script.
+            if (said?.refused)
+                throw new Error(said.refused);
+        },
+        async ask(args) {
+            await client.mutation(api.solutions.mutations.ask, {
+                solutionId: args.solutionId,
+                agent: args.agent,
+                outcome: args.outcome,
+                request: args.request,
+            });
+        },
+        async stall(args) {
+            await client.mutation(api.solutions.mutations.stall, {
+                solutionId: args.solutionId,
+                agent: args.agent,
+                outcome: args.outcome,
+                reason: args.reason,
+            });
+        },
+        async openDecision(solutionId, outcome) {
+            const page = await client.query(api.solutions.queries.getOutcomePage, { solutionId, outcome });
+            const decisionId = page?.panel?.decisionId;
+            return decisionId ? { id: decisionId } : null;
+        },
+        async answer(decisionId, answer) {
+            await client.mutation(api.solutions.mutations.answer, {
+                decisionId,
+                answer,
+            });
+        },
+        async approveCheckpoint(solutionId, checkpoint, words) {
+            await client.mutation(api.solutions.mutations.approveCheckpoint, {
+                solutionId,
+                checkpoint,
+                ...(words?.trim() ? { words: words.trim() } : {}),
+            });
+        },
+        async thread(solutionId, outcome) {
+            return ((await client.query(api.solutions.queries.getThread, {
+                solutionId,
+                outcome,
+            })) ?? []);
+        },
+        async things(solutionId, outcome) {
+            const things = await client.query(api.solutions.queries.getThings, { solutionId, name: outcome });
+            return things?.things ?? [];
+        },
+        async agentLog(solutionId, agent) {
+            const logs = await client.query(api.solutions.queries.getAgentLogs, { solutionId, agent });
+            if (logs.length === 0)
+                return null;
+            return logs
+                .map((log, i) => `Run ${logs.length - i} of ${logs.length}, ${new Date(log.at).toISOString()}:\n${log.summary}`)
+                .join("\n\n");
+        },
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    };
+}
+//# sourceMappingURL=live.js.map

package/dist/rehearsal/report.d.ts

@@ -0,0 +1,4 @@
+import type { RehearsalReport } from "./types.js";
+/** The rehearsal as text: how it ended, then each outcome's thread and things. */
+export declare function renderReport(report: RehearsalReport): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/rehearsal/report.js

@@ -0,0 +1,69 @@
+/** The rehearsal as text: how it ended, then each outcome's thread and things. */
+export function renderReport(report) {
+    const lines = [`# Rehearsal ${report.solutionId}`, ""];
+    if (report.earlier)
+        lines.push(...earlierLines(report.earlier), "");
+    lines.push(`Ended: ${report.ended}`);
+    for (const outcome of report.outcomes) {
+        lines.push("", `## ${outcome.outcome} — ${outcome.status}${outcome.reason ? ` (${outcome.reason})` : ""}`);
+        if (outcome.things.length > 0) {
+            lines.push("", "Submitted:");
+            for (const thing of outcome.things) {
+                lines.push(`- ${JSON.stringify(thing)}`);
+            }
+        }
+        if (outcome.thread.length > 0) {
+            lines.push("", "Thread:");
+            for (const entry of outcome.thread) {
+                const who = entry.agent ?? entry.by ?? "?";
+                const result = entry.result ? ` — ${entry.result}` : "";
+                lines.push(`- ${entry.kind} by ${who}${result}: ${entry.text ?? ""}`);
+            }
+        }
+        for (const [agent, log] of Object.entries(outcome.agentLogs ?? {})) {
+            if (log)
+                lines.push("", `${agent}, from its log:`, "", log);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Names as a person lists them: "a", "a and b", "a, b and c". */
+function listed(names) {
+    return names.length <= 1
+        ? (names[0] ?? "")
+        : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+/** What became of the scenario's earlier runs (REHEARSE-6.1, 6.5). */
+function earlierLines(earlier) {
+    const runs = earlier.removed === 1 ? "run" : "runs";
+    const lines = [
+        earlier.keep
+            ? `Removed no earlier runs of ${earlier.scenario}: --keep left them in place.`
+            : earlier.removed === 0 && !earlier.keptRuns?.length
+                ? `Removed no earlier runs of ${earlier.scenario}: there were none.`
+                : `Removed ${earlier.removed === 0 ? "no" : earlier.removed} earlier ${runs} of ${earlier.scenario}.`,
+    ];
+    // REHEARSE-6.2.0: an earlier run another scenario starts from stays whole.
+    for (const run of earlier.keptRuns ?? []) {
+        lines.push(`Kept the earlier run ${run.solutionId}, because ${listed(run.namedBy)} starts from its history.`);
+    }
+    for (const thing of earlier.kept) {
+        lines.push(thing.namedBy.length > 0
+            ? `Kept ${thing.reference}, which an earlier run made, because ${listed(thing.namedBy)} names it as an input.`
+            : `Kept ${thing.reference}, which an earlier run made, because another solution uses it.`);
+    }
+    // REHEARSE-6.7, 6.8, 6.10: the branch an earlier run's solution made.
+    for (const branch of earlier.branches ?? []) {
+        if (branch.outcome === "deleted") {
+            lines.push(`Deleted the branch ${branch.name}, which an earlier run's solution made.`);
+        }
+        else if (branch.outcome === "kept") {
+            lines.push(`Kept the branch ${branch.name}, which an earlier run's solution made, because ${branch.why ?? "the app didn't say why"}.`);
+        }
+        else if (branch.outcome === "pending") {
+            lines.push(`The branch ${branch.name}, which an earlier run's solution made, was still being deleted when this run started; if it is still there, this run's branch takes a suffixed name.`);
+        }
+    }
+    return lines;
+}
+//# sourceMappingURL=report.js.map