@popoverai/dotrequirements 0.33.0 → 0.34.0

package/dist/convex.js

@@ -25,6 +25,8 @@ export const api = {
             exportProject: query("documents/queries:exportProject"),
             // SHARE-TOKEN-3: the same export for a read-only share token
             exportProjectForShare: query("documents/queries:exportProjectForShare"),
+            // SYNC-FAIL-5: which of the workspace's ids name another project's document
+            foreignDocumentIds: query("documents/queries:foreignDocumentIds"),
         },
         mutations: {
             // SYNC-MODE-3: delete a cloud document from the CLI (repo-wins)
@@ -78,6 +80,68 @@ export const api = {
             ensureProjectShareToken: mutation("projectSecrets/mutations:ensureProjectShareToken"),
         },
     },
+    // VERB-7: scores made and revised from the shell, submitted as scores:<id>
+    scores: {
+        mutations: {
+            create: mutation("scores/mutations:create"),
+            update: mutation("scores/mutations:update"),
+        },
+    },
+    mockups: {
+        mutations: {
+            create: mutation("mockups/mutations:create"),
+        },
+    },
+    solutions: {
+        queries: {
+            getPlan: query("solutions/queries:getPlan"),
+            getThread: query("solutions/queries:getThread"),
+            getThings: query("solutions/queries:getThings"),
+            defaultPlan: query("solutions/queries:defaultPlan"),
+            readPlanFile: query("solutions/queries:readPlanFile"),
+            // An outcome's page: where it stands, and the decision open on it.
+            getOutcomePage: query("solutions/queries:getOutcomePage"),
+            getAgentLogs: query("solutions/queries:getAgentLogs"),
+            forSync: query("solutions/queries:forSync"),
+            rehearsalsOf: query("solutions/queries:rehearsalsOf"),
+            rehearsalHistory: query("solutions/queries:rehearsalHistory"),
+        },
+        mutations: {
+            create: mutation("solutions/mutations:create"),
+            start: mutation("solutions/mutations:start"),
+            next: mutation("solutions/mutations:next"),
+            complete: mutation("solutions/mutations:complete"),
+            ask: mutation("solutions/mutations:ask"),
+            stall: mutation("solutions/mutations:stall"),
+            answer: mutation("solutions/mutations:answer"),
+            // A rehearsal's scripted approval of a checkpoint (CHECKPOINT-1.1).
+            approveCheckpoint: mutation("solutions/mutations:approveCheckpoint"),
+            removeRehearsal: mutation("solutions/mutations:removeRehearsal"),
+            // SIGHT-7.0: where a video is uploaded before it is submitted
+            videoUploadUrl: mutation("solutions/mutations:videoUploadUrl"),
+        },
+        // SOLSHARE: a solution's share command, on its token alone.
+        shares: {
+            forCheckout: query("solutions/shares:forCheckout"),
+            push: mutation("solutions/shares:push"),
+            done: mutation("solutions/shares:done"),
+        },
+        // SIGHT-9: where an image is uploaded before it is submitted, and where
+        // the copies an outcome works on are fetched from.
+        images: {
+            uploadUrl: mutation("solutions/images:uploadUrl"),
+            // REHEARSE-4.7: an image a scenario names for an input, before the solution exists
+            inputUploadUrl: mutation("solutions/images:inputUploadUrl"),
+            copies: query("solutions/images:copies"),
+        },
+        // SOLBRANCH, REHEARSE-6.7: a solution's branch and its pushes.
+        branches: {
+            branchOf: query("solutions/branches:branchOf"),
+            claim: mutation("solutions/branches:claim"),
+            recordPush: mutation("solutions/branches:recordPush"),
+            removal: query("solutions/branches:removal"),
+        },
+    },
     lib: {
         authActions: {
             exchangeAuthorizationCode: action("lib/authActions:exchangeAuthorizationCode"),

package/dist/push/core.js

@@ -35,8 +35,13 @@ export function parseFilesForPush(filePaths) {
     for (const filePath of filePaths) {
         // Read raw file content
         const rawContent = fs.readFileSync(filePath, "utf-8");
-        // Parse to get metadata and requirements
-        const parsed = parseRequirementsFromFile(filePath);
+        // Parse to get metadata and requirements. A file without the
+        // `.requirements.md` name is a solution's other document (SOLDOC-3): it
+        // has no requirement blocks, maybe no frontmatter yet, and is still a
+        // document.
+        const parsed = parseRequirementsFromFile(filePath, {
+            solutionDocument: !filePath.endsWith(".requirements.md"),
+        });
         const flatRequirements = getAllRequirements(parsed.requirements);
         // Extract markdown content (everything after frontmatter)
         const markdownContent = extractMarkdownContent(rawContent);

package/dist/rehearsal/derive.d.ts

@@ -0,0 +1,23 @@
+import type { Plan, PlanPart } from "./types.js";
+/**
+ * Some of a plan's outcomes given their inputs (REHEARSE-1.0, 1.6, 1.8):
+ * the smallest plan holding those outcomes, in the plan's order and
+ * phases, whose inputs are what they await, are against or are on that
+ * none of them is, so they run as if the outcomes before them were made.
+ * So a scenario naming Scores alone, of the default plan, runs the scores
+ * with the pitch an input. An outcome on one left out is kept on that
+ * one's surface instead. The checkpoints on what is kept stay, presenting
+ * what is still there; loops go, since part of a plan starts or ends
+ * nothing.
+ *
+ * The one exception is the outcome that makes the solution exist: the
+ * plan's first outcome when the person makes it at creation, with an agent
+ * (the Idea in the default plan, which is the solution itself). When a
+ * chosen outcome works from it, it is kept at the head of the derived plan,
+ * so the solution is the idea there as in production, and the scenario
+ * names nothing for it.
+ */
+export declare function planForOutcomes(plan: Plan, names: readonly string[]): Plan;
+/** The plan a scenario names: the whole one, or some of its outcomes derived from it. */
+export declare function planOf(plan: Plan | PlanPart): Plan;
+//# sourceMappingURL=derive.d.ts.map

package/dist/rehearsal/derive.js

@@ -0,0 +1,112 @@
+/** Every outcome in the plan, in its order. */
+const outcomesOf = (plan) => plan.phases.flatMap((phase) => phase.outcomes);
+/** The surface an outcome is kept on: its own, or the one the outcome it is on is kept on. */
+function surfaceOf(plan, name) {
+    const seen = new Set();
+    let current = name;
+    for (;;) {
+        if (seen.has(current))
+            return undefined;
+        seen.add(current);
+        const outcome = outcomesOf(plan).find((each) => each.name === current);
+        if (!outcome) {
+            return plan.surfaces.find((surface) => surface.name === current)?.name;
+        }
+        if (plan.surfaces.some((surface) => surface.name === outcome.on)) {
+            return outcome.on;
+        }
+        current = outcome.on;
+    }
+}
+/** What an outcome waits on or works from: what it and its review await, what it is against, and the outcome it is on. */
+const worksFrom = (plan, outcome) => [
+    ...(outcome.awaits ?? []),
+    ...(outcome.reviewAwaits ?? []),
+    ...(outcome.against ?? []),
+    ...(outcomesOf(plan).some((each) => each.name === outcome.on)
+        ? [outcome.on]
+        : []),
+];
+/**
+ * Some of a plan's outcomes given their inputs (REHEARSE-1.0, 1.6, 1.8):
+ * the smallest plan holding those outcomes, in the plan's order and
+ * phases, whose inputs are what they await, are against or are on that
+ * none of them is, so they run as if the outcomes before them were made.
+ * So a scenario naming Scores alone, of the default plan, runs the scores
+ * with the pitch an input. An outcome on one left out is kept on that
+ * one's surface instead. The checkpoints on what is kept stay, presenting
+ * what is still there; loops go, since part of a plan starts or ends
+ * nothing.
+ *
+ * The one exception is the outcome that makes the solution exist: the
+ * plan's first outcome when the person makes it at creation, with an agent
+ * (the Idea in the default plan, which is the solution itself). When a
+ * chosen outcome works from it, it is kept at the head of the derived plan,
+ * so the solution is the idea there as in production, and the scenario
+ * names nothing for it.
+ */
+export function planForOutcomes(plan, names) {
+    const all = outcomesOf(plan);
+    for (const name of names) {
+        if (!all.some((outcome) => outcome.name === name)) {
+            throw new Error(`The plan has no outcome called "${name}". Its outcomes: ${all.map((outcome) => outcome.name).join(", ")}.`);
+        }
+    }
+    const chosen = new Set(names);
+    const first = all[0];
+    const creation = first?.createdWith !== undefined && !chosen.has(first.name)
+        ? first
+        : undefined;
+    const picked = all.filter((outcome) => chosen.has(outcome.name));
+    const needed = [
+        ...new Set(picked.flatMap((outcome) => worksFrom(plan, outcome))),
+    ].filter((name) => !chosen.has(name));
+    const keepsCreation = !!creation && needed.includes(creation.name);
+    const kept = new Set([
+        ...chosen,
+        ...(keepsCreation && creation ? [creation.name] : []),
+    ]);
+    const inputs = [
+        ...plan.inputs.filter((name) => needed.includes(name)),
+        ...all
+            .map((outcome) => outcome.name)
+            .filter((name) => needed.includes(name) && !kept.has(name)),
+    ];
+    const phases = plan.phases.flatMap((phase) => {
+        const outcomes = phase.outcomes
+            .filter((outcome) => kept.has(outcome.name))
+            .map((outcome) => 
+        // On an outcome left out, it is kept on that one's surface.
+        all.some((each) => each.name === outcome.on) && !kept.has(outcome.on)
+            ? { ...outcome, on: surfaceOf(plan, outcome.on) ?? outcome.on }
+            : outcome);
+        return outcomes.length > 0 ? [{ ...phase, outcomes }] : [];
+    });
+    const known = new Set([...kept, ...inputs]);
+    const keptOn = (on) => kept.has(on) ||
+        [...kept].some((name) => surfaceOf(plan, name) === on && name !== on);
+    const checkpoints = plan.checkpoints.flatMap((checkpoint) => {
+        if (!keptOn(checkpoint.on))
+            return [];
+        if (!checkpoint.presents?.length)
+            return [checkpoint];
+        const presents = checkpoint.presents.filter((name) => known.has(name));
+        return presents.length > 0 ? [{ ...checkpoint, presents }] : [];
+    });
+    return {
+        format: "outcomes",
+        inputs,
+        surfaces: plan.surfaces,
+        phases,
+        checkpoints,
+        agents: plan.agents,
+        loops: [],
+    };
+}
+/** The plan a scenario names: the whole one, or some of its outcomes derived from it. */
+export function planOf(plan) {
+    if (!("from" in plan))
+        return plan;
+    return planForOutcomes(plan.from, plan.outcomes);
+}
+//# sourceMappingURL=derive.js.map

package/dist/rehearsal/driver.d.ts

@@ -0,0 +1,44 @@
+import type { Party, Plan, RehearsalClient, RehearsalReport, Scenario } from "./types.js";
+/**
+ * The plan a scenario rehearses, refused when it names an outcome the plan
+ * doesn't have or leaves one of its inputs holding nothing: what a live
+ * rehearsal checks before it removes the scenario's earlier runs, so a
+ * mistake in the scenario never costs the run under review. An input the
+ * scenario doesn't name holds something when the earlier rehearsal it
+ * starts from holds it (REHEARSE-4.8).
+ */
+export declare function checkScenario(scenario: Scenario): Plan;
+/** A part of an outcome's work: drafting it, reviewing it, or, with no agent, making it from outside. */
+export type Part = {
+    outcome: string;
+    part: "draft" | "review" | "outside";
+    /** The agent; absent for an outcome someone outside, or the owner with an agent, makes. */
+    agent?: string;
+    /** Who makes it from outside, when the panel says. */
+    party?: string;
+};
+/**
+ * Who plays an agent at a part of an outcome's work in a scenario: the key
+ * naming that agent on that outcome (`Code/Code Reviewer`), then the key
+ * naming the part — the outcome's name for its drafter or whoever makes it
+ * from outside (`Pitch`), "<outcome>/reviewer" for its reviewers
+ * (`Pitch/reviewer`) — then the agent's own name (`Acceptance Tester`, or
+ * `Pitch/drafter` for one dedicated to its outcome), then whoever outside
+ * makes it (`release manager`). Unnamed, an agent is real. The key that
+ * matched, for counting turns.
+ */
+export declare function partiesOf(parties: Scenario["parties"]): (at: Part) => {
+    party: Party;
+    key: string;
+};
+/**
+ * The driver (docs/working/rehearsing-steps.md): the orchestrator the
+ * product has as events, as a loop. Look at where every outcome stands;
+ * for each part of the work due, find who plays its agent; play a script
+ * through the same verbs an agent uses — `next` for the agent, then what
+ * its script records — or wait for a real one; answer decisions and
+ * checkpoints from the person's script; stop when nothing is ready, or
+ * when something needs a person nobody scripted, or an agent stalls.
+ */
+export declare function rehearse(client: RehearsalClient, scenario: Scenario): Promise<RehearsalReport>;
+//# sourceMappingURL=driver.d.ts.map

package/dist/rehearsal/driver.js

@@ -0,0 +1,337 @@
+import { planOf } from "./derive.js";
+/**
+ * The plan a scenario rehearses, refused when it names an outcome the plan
+ * doesn't have or leaves one of its inputs holding nothing: what a live
+ * rehearsal checks before it removes the scenario's earlier runs, so a
+ * mistake in the scenario never costs the run under review. An input the
+ * scenario doesn't name holds something when the earlier rehearsal it
+ * starts from holds it (REHEARSE-4.8).
+ */
+export function checkScenario(scenario) {
+    const plan = planOf(scenario.plan);
+    for (const name of plan.inputs) {
+        if (scenario.inputs?.[name])
+            continue;
+        if (scenario.history?.outcomes.includes(name))
+            continue;
+        throw new Error(scenario.history
+            ? `The plan's input "${name}" holds nothing: solution ${scenario.history.solution} held no "${name}" when it made "${scenario.history.after}", so name its artifacts in the scenario.`
+            : `The plan's input "${name}" holds nothing: name its artifacts in the scenario.`);
+    }
+    return plan;
+}
+/**
+ * Who plays an agent at a part of an outcome's work in a scenario: the key
+ * naming that agent on that outcome (`Code/Code Reviewer`), then the key
+ * naming the part — the outcome's name for its drafter or whoever makes it
+ * from outside (`Pitch`), "<outcome>/reviewer" for its reviewers
+ * (`Pitch/reviewer`) — then the agent's own name (`Acceptance Tester`, or
+ * `Pitch/drafter` for one dedicated to its outcome), then whoever outside
+ * makes it (`release manager`). Unnamed, an agent is real. The key that
+ * matched, for counting turns.
+ */
+export function partiesOf(parties) {
+    return (at) => {
+        const keys = [
+            ...(at.agent ? [`${at.outcome}/${at.agent}`] : []),
+            at.part === "review" ? `${at.outcome}/reviewer` : at.outcome,
+            ...(at.agent ? [at.agent] : []),
+            ...(at.party ? [at.party] : []),
+        ];
+        const key = keys.find((name) => parties[name] !== undefined);
+        return key ? { party: parties[key], key } : { party: "real", key: keys[0] };
+    };
+}
+/** Every outcome on the panel, in the plan's order. */
+const outcomesOn = (panel) => (panel?.phases ?? []).flatMap((phase) => phase.outcomes);
+/**
+ * The parts of the work an agent, or someone outside, could take now or is
+ * at, in the plan's order: a ready or drafting outcome's draft, a review of
+ * an outcome standing reviewing (each of its reviewers, since the panel
+ * doesn't say which have given their result), and an outcome waiting on
+ * whoever makes it from outside.
+ */
+function partsDue(outcomes) {
+    return outcomes.flatMap((outcome) => {
+        if ((outcome.status === "ready" || outcome.status === "drafting") &&
+            outcome.drafter) {
+            return [{ outcome: outcome.name, part: "draft", agent: outcome.drafter }];
+        }
+        if (outcome.status === "reviewing") {
+            return (outcome.reviewers ?? []).map((agent) => ({
+                outcome: outcome.name,
+                part: "review",
+                agent,
+            }));
+        }
+        if (outcome.status === "awaiting external" ||
+            outcome.status === "awaiting collaboration") {
+            return [
+                {
+                    outcome: outcome.name,
+                    part: "outside",
+                    ...(outcome.party ? { party: outcome.party } : {}),
+                },
+            ];
+        }
+        return [];
+    });
+}
+/**
+ * The driver (docs/working/rehearsing-steps.md): the orchestrator the
+ * product has as events, as a loop. Look at where every outcome stands;
+ * for each part of the work due, find who plays its agent; play a script
+ * through the same verbs an agent uses — `next` for the agent, then what
+ * its script records — or wait for a real one; answer decisions and
+ * checkpoints from the person's script; stop when nothing is ready, or
+ * when something needs a person nobody scripted, or an agent stalls.
+ */
+export async function rehearse(client, scenario) {
+    const plan = checkScenario(scenario);
+    const inputs = Object.entries(scenario.inputs ?? {}).map(([name, things]) => ({ name, things }));
+    const solutionId = await client.create({
+        title: scenario.title,
+        scenario: scenario.file,
+        description: scenario.description,
+        plan,
+        inputs,
+        ...(scenario.branch ? { branch: scenario.branch } : {}),
+        ...(scenario.published?.length ? { published: scenario.published } : {}),
+        ...(scenario.history
+            ? {
+                history: {
+                    solution: scenario.history.solution,
+                    after: scenario.history.after,
+                },
+            }
+            : {}),
+    });
+    const partyFor = partiesOf(scenario.parties);
+    const played = {};
+    /** The script for this turn: the n-th of a list, the last repeating, counted by outcome and agent. */
+    const scriptFor = (at, party) => {
+        if (!Array.isArray(party))
+            return party;
+        const key = `${at.outcome}/${at.agent ?? at.part}`;
+        const n = played[key] ?? 0;
+        played[key] = n + 1;
+        return party[Math.min(n, party.length - 1)];
+    };
+    const asked = {};
+    /** The person's next scripted answer under a name, taken. */
+    const answerFor = (name) => {
+        const answers = scenario.person?.[name] ?? [];
+        const n = asked[name] ?? 0;
+        const answer = answers[n];
+        if (answer)
+            asked[name] = n + 1;
+        return answer;
+    };
+    const waited = {};
+    const waitMs = scenario.waitMs ?? 20 * 60 * 1000;
+    const pollMs = 15_000;
+    let ended = "nothing ready";
+    for (let turn = 0; turn < 500; turn++) {
+        const panel = await client.panel(solutionId);
+        const outcomes = outcomesOn(panel);
+        // A decision waiting: the person's script answers, or the rehearsal ends.
+        const deciding = outcomes.find((o) => o.status === "awaiting decision");
+        if (deciding) {
+            const decision = await client.openDecision?.(solutionId, deciding.name);
+            const answer = decision && client.answer ? answerFor(deciding.name) : undefined;
+            if (!answer || !decision || !client.answer) {
+                ended = `"${deciding.name}" waits on a decision nobody scripted`;
+                break;
+            }
+            await client.answer(decision.id, answer);
+            continue;
+        }
+        const stalled = outcomes.find((o) => o.status === "stalled");
+        if (stalled) {
+            ended = `"${stalled.name}" stalled: ${stalled.reason ?? "no reason given"}`;
+            break;
+        }
+        // A checkpoint waiting on the person: her scripted approval, or the end.
+        const checkpoint = panel?.checkpoints?.find((c) => c.stands === "deciding");
+        if (checkpoint) {
+            const answer = client.approveCheckpoint
+                ? answerFor(checkpoint.name)
+                : undefined;
+            if (!answer || !client.approveCheckpoint) {
+                ended = `the ${checkpoint.name} checkpoint waits on a decision nobody scripted`;
+                break;
+            }
+            if (answer.kind !== "approval" || answer.outcome !== "approved") {
+                throw new Error(`The person's script answers the ${checkpoint.name} checkpoint with an approval: { kind: approval, outcome: approved }, with any comment as her words.`);
+            }
+            await client.approveCheckpoint(solutionId, checkpoint.name, answer.comment);
+            continue;
+        }
+        // The parts due, scripted ones first: a script takes its agent's work
+        // through `next`, as the agent would.
+        const due = partsDue(outcomes).map((at) => ({ at, ...partyFor(at) }));
+        let acted = false;
+        for (const { at, party } of due) {
+            if (party === "real")
+                continue;
+            if (at.part === "outside") {
+                await playOutside(client, solutionId, at, scriptFor(at, party));
+                acted = true;
+                break;
+            }
+            const brief = await client.next({ solutionId, agent: at.agent });
+            if (brief.kind === "nothing ready")
+                continue;
+            const taken = takenPart(brief, at.agent);
+            const script = partyFor(taken);
+            if (script.party === "real") {
+                throw new Error(`${at.agent} is scripted for "${at.outcome}" but real for "${taken.outcome}", which it took first: script it for both, or neither.`);
+            }
+            await play(client, solutionId, taken, scriptFor(taken, script.party), brief);
+            acted = true;
+            break;
+        }
+        if (acted)
+            continue;
+        // Nothing a script could take: wait for a real agent at work or due.
+        const real = due
+            .filter(({ at, party }) => party === "real" && at.part !== "outside")
+            .map(({ at }) => ({ outcome: at.outcome, agent: at.agent }))[0];
+        if (!real) {
+            ended = "nothing ready";
+            break;
+        }
+        if (!client.sleep) {
+            throw new Error(`${real.agent} is real on "${real.outcome}", and only a live rehearsal can wait for a real agent.`);
+        }
+        const key = `${real.outcome}/${real.agent}`;
+        waited[key] = (waited[key] ?? 0) + pollMs;
+        if (waited[key] > waitMs) {
+            ended = `"${real.outcome}" waited ${Math.round(waitMs / 60000)} minutes for ${real.agent}`;
+            break;
+        }
+        await client.sleep(pollMs);
+    }
+    const reports = [];
+    for (const outcome of outcomesOn(await client.panel(solutionId))) {
+        const report = {
+            outcome: outcome.name,
+            status: outcome.status,
+            reason: outcome.reason,
+            things: await client.things(solutionId, outcome.name),
+            thread: await client.thread(solutionId, outcome.name),
+        };
+        if (client.agentLog) {
+            const agents = [
+                ...(outcome.drafter ? [outcome.drafter] : []),
+                ...(outcome.reviewers ?? []),
+            ];
+            const logs = {};
+            for (const agent of agents) {
+                const part = {
+                    outcome: outcome.name,
+                    part: agent === outcome.drafter ? "draft" : "review",
+                    agent,
+                };
+                if (partyFor(part).party === "real") {
+                    logs[agent] = await client.agentLog(solutionId, agent);
+                }
+            }
+            if (Object.keys(logs).length > 0)
+                report.agentLogs = logs;
+        }
+        reports.push(report);
+    }
+    return { solutionId, ended, outcomes: reports };
+}
+/** The part a brief hands the agent: the outcome it names, drafting or reviewing it. */
+function takenPart(brief, agent) {
+    const step = brief.step;
+    const outcome = step?.outcome ?? step?.label;
+    if (!outcome) {
+        throw new Error(`${agent} was given a brief that names no outcome.`);
+    }
+    return { outcome, part: brief.kind === "review" ? "review" : "draft", agent };
+}
+/** A script for an agent: check the brief it was given as the agent would read it, then act. */
+async function play(client, solutionId, at, script, brief) {
+    const agent = at.agent;
+    const { outcome } = at;
+    const where = `"${outcome}" (${agent}, ${at.part === "review" ? "reviewing" : "drafting"})`;
+    if (script.expect) {
+        try {
+            script.expect(brief);
+        }
+        catch (error) {
+            throw new Error(`${where}: the brief isn't what the script expected — ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (script.stall) {
+        await client.stall({ solutionId, agent, outcome, reason: script.stall });
+        return;
+    }
+    if (script.ask) {
+        await client.ask({ solutionId, agent, outcome, request: script.ask });
+        return;
+    }
+    // REHEARSE-1.1: a script records exactly as a real agent does, so an
+    // approval carries the summary the script gives (VERB-2.5) and none
+    // stands in for a missing one; the backend refuses it as it would the
+    // agent's.
+    if (at.part === "review") {
+        if (!script.review) {
+            throw new Error(`${where}: the script gives no review — give it review, ask or stall.`);
+        }
+        await client.complete({
+            solutionId,
+            agent,
+            outcome,
+            review: script.review,
+        });
+        return;
+    }
+    const made = await madeBy(client, script);
+    if (!made) {
+        throw new Error(`${where}: the script says nothing to do — give it made, scores, ask or stall.`);
+    }
+    await client.complete({
+        solutionId,
+        agent,
+        outcome,
+        made,
+        comment: script.comment,
+        summary: script.summary,
+    });
+}
+/** What a script submits: its things, or the scores it makes first, as `dotreq scores create` would. */
+async function madeBy(client, script) {
+    if (script.made)
+        return script.made;
+    if (script.scores) {
+        return [
+            {
+                kind: "scores",
+                scoresId: await client.createScores(script.scores),
+            },
+        ];
+    }
+    return undefined;
+}
+/**
+ * A script for whoever makes an outcome from outside the product, or the
+ * owner with an agent: it closes the outcome with what it made, as their
+ * close would (AWAIT-7.1: a rehearsal's scripts play every party).
+ */
+async function playOutside(client, solutionId, at, script) {
+    const made = await madeBy(client, script);
+    if (!made) {
+        throw new Error(`"${at.outcome}" (${at.party ?? "made outside"}): the script says nothing to do — give it made or scores.`);
+    }
+    await client.complete({
+        solutionId,
+        outcome: at.outcome,
+        made,
+        comment: script.comment,
+    });
+}
+//# sourceMappingURL=driver.js.map

package/dist/rehearsal/earlier.d.ts

@@ -0,0 +1,25 @@
+import type { solutionClient } from "../commands/solution/client.js";
+import type { EarlierRuns } from "./types.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 declare function namedInputs(scenarioPath: string): Map<string, string[]>;
+/**
+ * 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 declare function removeEarlierRuns(scenarioPath: string, client: ReturnType<typeof solutionClient>, pause?: (ms: number) => Promise<void>): Promise<EarlierRuns>;
+//# sourceMappingURL=earlier.d.ts.map