@popoverai/dotrequirements 0.32.1 → 0.34.0

package/dist/commands/solution/brief.d.ts

@@ -0,0 +1,81 @@
+/**
+ * What `dotreq solution next` prints. The brief for an outcome is composed
+ * in the backend, entirely from blocks (docs/working/prompt-blocks.md), and
+ * arrives as `text`; the CLI prints it as given and renders nothing of its
+ * own. The shapes mirror what `solutions/mutations:next` and
+ * `solutions/queries:getPlan` return, as far as the CLI reads them (the CLI
+ * doesn't import the backend's types).
+ */
+/**
+ * An outcome to draft (`step`) or to review (`review`): the outcome, the
+ * brief the agent reads, and the outcomes it reviews and works from, whose
+ * images and demo scripts `next` saves in the checkout (SIGHT-9.3, 13.1).
+ */
+export type Brief = {
+    kind: "step" | "review";
+    /** The outcome the agent took; `label` is its name too. */
+    step: {
+        label: string;
+        outcome?: string;
+    };
+    text: string;
+    reviewing?: BriefOutcome[];
+    against?: BriefOutcome[];
+};
+/** An outcome the brief lists, as far as the CLI reads it. */
+export type BriefOutcome = {
+    name: string;
+    things?: Array<{
+        kind: string;
+        storageId?: string;
+        name?: string;
+        script?: string;
+    }>;
+};
+/** An outcome on the plan panel, as far as the CLI reads it. */
+export type PanelOutcome = {
+    name: string;
+    /** The one word it stands in: ready, drafting, reviewing, awaiting decision, stalled, done... */
+    status: string;
+    /** The agent that drafts it, when an agent of ours does. */
+    drafter?: string;
+    /** The agents that review it. */
+    reviewers?: string[];
+    /** Why one of its agents stalled. */
+    reason?: string;
+    /** Who it waits on, when someone outside creates it. */
+    party?: string;
+    /** For an outcome not started: what it can't begin without. */
+    waitingFor?: string[];
+    /** Its drafter's work was set aside and its new draft isn't taken yet: a session at it owes nothing more (CHECKPOINT-6.3.2.3). */
+    setAside?: boolean;
+};
+/** A checkpoint on the plan panel, as far as the CLI reads it. */
+export type PanelCheckpoint = {
+    name: string;
+    /** waiting, deciding (on the owner now), fixing, deferred or approved. */
+    stands: string;
+};
+/** The plan panel (`getPlan`): its outcomes by phase, and its checkpoints. */
+export type Panel = {
+    title: string;
+    phases: Array<{
+        name: string;
+        outcomes: PanelOutcome[];
+    }>;
+    checkpoints?: PanelCheckpoint[];
+};
+export type Standing = {
+    kind: "nothing ready";
+    plan: Panel;
+};
+export type NextResult = Brief | Standing;
+export declare const EXIT: {
+    /** Nothing is ready: a loop of `next` can stop here. */
+    readonly nothingReady: 3;
+};
+/** Every outcome on the panel, in the plan's order. */
+export declare function outcomesOf(panel: Pick<Panel, "phases">): PanelOutcome[];
+/** Nothing ready: every outcome and what it waits on, then any checkpoint the owner is at. */
+export declare function renderStanding({ plan }: Standing): string;
+//# sourceMappingURL=brief.d.ts.map

package/dist/commands/solution/brief.js

@@ -0,0 +1,47 @@
+/**
+ * What `dotreq solution next` prints. The brief for an outcome is composed
+ * in the backend, entirely from blocks (docs/working/prompt-blocks.md), and
+ * arrives as `text`; the CLI prints it as given and renders nothing of its
+ * own. The shapes mirror what `solutions/mutations:next` and
+ * `solutions/queries:getPlan` return, as far as the CLI reads them (the CLI
+ * doesn't import the backend's types).
+ */
+export const EXIT = {
+    /** Nothing is ready: a loop of `next` can stop here. */
+    nothingReady: 3,
+};
+/** Every outcome on the panel, in the plan's order. */
+export function outcomesOf(panel) {
+    return panel.phases.flatMap((phase) => phase.outcomes);
+}
+/** Nothing ready: every outcome and what it waits on, then any checkpoint the owner is at. */
+export function renderStanding({ plan }) {
+    const lines = [`Nothing is ready on "${plan.title}".`, ""];
+    for (const outcome of outcomesOf(plan)) {
+        lines.push(`- ${outcome.name}: ${standing(outcome)}`);
+    }
+    for (const checkpoint of plan.checkpoints ?? []) {
+        const stands = CHECKPOINT_STANDS[checkpoint.stands];
+        if (stands)
+            lines.push(`- The ${checkpoint.name} checkpoint: ${stands}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** A checkpoint worth a line when nothing is ready: one that holds the work up. */
+const CHECKPOINT_STANDS = {
+    deciding: "waiting on the owner's decision",
+    fixing: "a fix is running",
+    deferred: "deferred by the owner",
+};
+function standing(outcome) {
+    if (outcome.status === "stalled" && outcome.reason)
+        return `stalled — ${outcome.reason}`;
+    if (outcome.status === "awaiting external" && outcome.party) {
+        return `awaiting ${outcome.party}`;
+    }
+    if (outcome.status === "not started" && outcome.waitingFor?.length) {
+        return `not started — after ${outcome.waitingFor.join(", ")}`;
+    }
+    return outcome.status;
+}
+//# sourceMappingURL=brief.js.map

package/dist/commands/solution/checkout.d.ts

@@ -0,0 +1,27 @@
+import { type WhereOptions } from "./run-file.js";
+/**
+ * `dotreq solution checkout`: what the runner runs in its checkout before
+ * each session (SOLBRANCH-1, 2). Puts the checkout on the branch of the
+ * surface the outcome is kept on (1.5), making it on that surface's first
+ * session, and brings in what other agents pushed to it. Prints the branch and what the agent is to
+ * be told before its brief, if anything; with `--json`, as one line the
+ * runner reads.
+ */
+export declare function checkoutCommand(options: WhereOptions & {
+    json?: boolean;
+    share?: string;
+    branchWins?: boolean;
+}): Promise<void>;
+/**
+ * `dotreq solution push`: what the runner runs when a session ends
+ * (SOLBRANCH-4.0). Pushes the commits the agent made after its last record
+ * to the run's branch, its commits after any other agents pushed since;
+ * never commits what it left uncommitted (SOLBRANCH-6.0). Prints whether
+ * it pushed and, when it couldn't, why; with `--json`, as one line.
+ * Outside a runner there is no branch to push to, and nothing happens.
+ */
+export declare function pushCommand(options: WhereOptions & {
+    json?: boolean;
+    repoWins?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=checkout.d.ts.map

package/dist/commands/solution/checkout.js

@@ -0,0 +1,66 @@
+import { solutionClient } from "./client.js";
+import { checkOutSolution, pushWork } from "./pushing.js";
+import { requireSolution, whereOf } from "./run-file.js";
+import { shareCheckout, sharePush } from "./share.js";
+/**
+ * `dotreq solution checkout`: what the runner runs in its checkout before
+ * each session (SOLBRANCH-1, 2). Puts the checkout on the branch of the
+ * surface the outcome is kept on (1.5), making it on that surface's first
+ * session, and brings in what other agents pushed to it. Prints the branch and what the agent is to
+ * be told before its brief, if anything; with `--json`, as one line the
+ * runner reads.
+ */
+export async function checkoutCommand(options) {
+    // SOLSHARE-2: from any repository, on a solution's share command.
+    if (options.share) {
+        await shareCheckout(options.share, (options.outcome ?? options.step)?.trim() || undefined, options.branchWins);
+        return;
+    }
+    const { solutionId } = requireSolution(options);
+    // SOLBRANCH-1.5: the branch of the surface the outcome is kept on.
+    const outcome = (options.outcome ?? options.step)?.trim() || undefined;
+    const { branch, notice } = await checkOutSolution(solutionClient(), solutionId, process.cwd(), outcome);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ branch, notice })}\n`);
+        return;
+    }
+    console.log(`On ${branch}.`);
+    if (notice)
+        console.log(`\n${notice}`);
+}
+/**
+ * `dotreq solution push`: what the runner runs when a session ends
+ * (SOLBRANCH-4.0). Pushes the commits the agent made after its last record
+ * to the run's branch, its commits after any other agents pushed since;
+ * never commits what it left uncommitted (SOLBRANCH-6.0). Prints whether
+ * it pushed and, when it couldn't, why; with `--json`, as one line.
+ * Outside a runner there is no branch to push to, and nothing happens.
+ */
+export async function pushCommand(options) {
+    const where = whereOf(options);
+    // SOLSHARE-3: a repository a solution was checked out into, with no run.
+    if (!where.branch && (await sharePush(options.solution, options.repoWins)))
+        return;
+    if (!where.branch && !options.json) {
+        throw new Error("No solution is checked out here: run the share command you were given first.");
+    }
+    const outcome = where.solutionId && where.branch
+        ? await pushWork(solutionClient(), {
+            solutionId: where.solutionId,
+            branch: where.branch,
+        })
+        : { ok: true, pushed: false };
+    const result = outcome.ok
+        ? { pushed: outcome.pushed, failure: null }
+        : { pushed: false, failure: outcome.why };
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        return;
+    }
+    console.log(result.failure
+        ? `Not pushed: ${result.failure}.`
+        : result.pushed
+            ? `Pushed to ${where.branch}.`
+            : "Nothing to push.");
+}
+//# sourceMappingURL=checkout.js.map

package/dist/commands/solution/client.d.ts

@@ -0,0 +1,16 @@
+import type { FunctionReference } from "convex/server";
+/**
+ * Calls against the linked project, for the solution verbs: the project's
+ * credentials on every call, and a refusal from the backend surfaced in its
+ * own words. A call to an endpoint that names the project passes `project`
+ * itself.
+ */
+export declare function solutionClient(): {
+    /** The linked project, by its slug or id. */
+    project: string;
+    mutation: <R>(fn: FunctionReference<"mutation">, args: Record<string, unknown>) => Promise<R>;
+    query: <R>(fn: FunctionReference<"query">, args: Record<string, unknown>) => Promise<R>;
+};
+/** A backend refusal, in the words the backend gave: a plain message, or a plan's broken rules listed. */
+export declare function refusal(data: unknown): string;
+//# sourceMappingURL=client.d.ts.map

package/dist/commands/solution/client.js

@@ -0,0 +1,46 @@
+import { ConvexHttpClient } from "convex/browser";
+import { ConvexError } from "convex/values";
+import { convexUrl } from "../../cloud.js";
+import { getProjectCredentials } from "../../utils/project-settings.js";
+/**
+ * Calls against the linked project, for the solution verbs: the project's
+ * credentials on every call, and a refusal from the backend surfaced in its
+ * own words. A call to an endpoint that names the project passes `project`
+ * itself.
+ */
+export function solutionClient() {
+    const { projectId, projectSecret } = getProjectCredentials();
+    const client = new ConvexHttpClient(convexUrl());
+    const auth = { projectAuth: { projectSlug: projectId, projectSecret } };
+    return {
+        /** The linked project, by its slug or id. */
+        project: projectId,
+        mutation: (fn, args) => inWords(() => client.mutation(fn, { ...auth, ...args })),
+        query: (fn, args) => inWords(() => client.query(fn, { ...auth, ...args })),
+    };
+}
+async function inWords(call) {
+    try {
+        return await call();
+    }
+    catch (error) {
+        if (error instanceof ConvexError)
+            throw new Error(refusal(error.data));
+        throw error;
+    }
+}
+/** A backend refusal, in the words the backend gave: a plain message, or a plan's broken rules listed. */
+export function refusal(data) {
+    if (typeof data === "string")
+        return data;
+    if (data && typeof data === "object") {
+        const { kind, rules, message } = data;
+        if (kind === "invalid plan" && rules?.length) {
+            return `The plan breaks these rules:\n- ${rules.join("\n- ")}`;
+        }
+        if (message)
+            return message;
+    }
+    return JSON.stringify(data);
+}
+//# sourceMappingURL=client.js.map

package/dist/commands/solution/contract.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The request file `ask` reads, in words: what `dotreq solution ask --help`
+ * prints after its options, the way `author --help` carries the reference
+ * forms. The backend's `describeContract()` renders it from the schema the
+ * request is validated against; the CLI can't import the backend, so this
+ * is that text, and a test keeps the two the same.
+ */
+export declare const REQUEST_CONTRACT = "Ask the person to decide something about the outcome you are drafting. A choice presents options with a recommendation. One decision per request: if two things need deciding, ask twice.\n\nA request is JSON with a \"kind\" and the fields of that kind:\n\nchoice:\n  question (text, up to 200 characters): The question, phrased as a question in the words the person will read it, not as a topic.\n  options (list, at least 2): The live alternatives. More than four makes deciding harder; give more only when each is a genuine choice. Leave out anything you have already ruled out.\n    name (text, up to 200 characters): The option as you would say it to the person: a noun phrase they can repeat back, not a label.\n    benefits (list of text, each up to 200 characters): What is better if this option is taken. One line each, in your own words.\n    costs (list of text, each up to 200 characters): What is worse if this option is taken: what it would take to build, and what the person lives with afterwards. Effort is a cost like any other.\n    note (text, up to 600 characters, optional): Anything you learned or checked about this option that is not a benefit or a cost. Leave it out when there is nothing to add.\n  recommendation (object): Which option you would take, and the one reason why.\n    option (text, up to 200 characters): The name of the option you recommend, exactly as it appears in options.\n    because (text, up to 200 characters): The one reason that carries it, in one line. The full reasoning belongs in background.\n  background (text, up to 4000 characters): What the person needs to know to decide well that the options do not already say. Include only context that would substantially change the quality of the decision. The person reads this after the options, so do not reiterate them.";
+//# sourceMappingURL=contract.d.ts.map

package/dist/commands/solution/contract.js

@@ -0,0 +1,23 @@
+/**
+ * The request file `ask` reads, in words: what `dotreq solution ask --help`
+ * prints after its options, the way `author --help` carries the reference
+ * forms. The backend's `describeContract()` renders it from the schema the
+ * request is validated against; the CLI can't import the backend, so this
+ * is that text, and a test keeps the two the same.
+ */
+export const REQUEST_CONTRACT = `Ask the person to decide something about the outcome you are drafting. A choice presents options with a recommendation. One decision per request: if two things need deciding, ask twice.
+
+A request is JSON with a "kind" and the fields of that kind:
+
+choice:
+  question (text, up to 200 characters): The question, phrased as a question in the words the person will read it, not as a topic.
+  options (list, at least 2): The live alternatives. More than four makes deciding harder; give more only when each is a genuine choice. Leave out anything you have already ruled out.
+    name (text, up to 200 characters): The option as you would say it to the person: a noun phrase they can repeat back, not a label.
+    benefits (list of text, each up to 200 characters): What is better if this option is taken. One line each, in your own words.
+    costs (list of text, each up to 200 characters): What is worse if this option is taken: what it would take to build, and what the person lives with afterwards. Effort is a cost like any other.
+    note (text, up to 600 characters, optional): Anything you learned or checked about this option that is not a benefit or a cost. Leave it out when there is nothing to add.
+  recommendation (object): Which option you would take, and the one reason why.
+    option (text, up to 200 characters): The name of the option you recommend, exactly as it appears in options.
+    because (text, up to 200 characters): The one reason that carries it, in one line. The full reasoning belongs in background.
+  background (text, up to 4000 characters): What the person needs to know to decide well that the options do not already say. Include only context that would substantially change the quality of the decision. The person reads this after the options, so do not reiterate them.`;
+//# sourceMappingURL=contract.js.map

package/dist/commands/solution/create.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `dotreq solution create [file]`: with no file, a solution from the
+ * project's default plan, titled with `--title`; with a plan file (YAML or
+ * JSON), its title, its description, its plan in the stored shape, and the
+ * inputs that already exist. `--description` says what the solution is
+ * beyond its title, in Markdown, and wins over the file's. The backend validates the plan and refuses an invalid one
+ * with the rules it broke.
+ */
+export declare function createCommand(file: string | undefined, options?: {
+    title?: string;
+    description?: string;
+    idea?: string[];
+}): Promise<void>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/solution/create.js

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { api } from "../../convex.js";
+import { solutionClient } from "./client.js";
+import { planPayload, readPlanFile } from "./plan-file.js";
+import { parseThing } from "./things.js";
+/**
+ * `dotreq solution create [file]`: with no file, a solution from the
+ * project's default plan, titled with `--title`; with a plan file (YAML or
+ * JSON), its title, its description, its plan in the stored shape, and the
+ * inputs that already exist. `--description` says what the solution is
+ * beyond its title, in Markdown, and wins over the file's. The backend validates the plan and refuses an invalid one
+ * with the rules it broke.
+ */
+export async function createCommand(file, options = {}) {
+    const idea = options.idea?.map(parseThing);
+    const described = options.description?.trim() || undefined;
+    if (!file) {
+        const title = options.title?.trim();
+        if (!title) {
+            throw new Error("A solution from the project's default plan needs a title: --title <title>.");
+        }
+        const client = solutionClient();
+        const id = await client.mutation(api.solutions.mutations.create, {
+            project: client.project,
+            title,
+            description: described,
+            idea,
+        });
+        console.log(`Created "${title}" from the project's default plan: ${id}`);
+        return;
+    }
+    const spec = readPlanFile(readFileSync(resolve(process.cwd(), file), "utf8"), file);
+    const title = options.title?.trim() ||
+        (typeof spec?.title === "string" ? spec.title : undefined);
+    if (!spec?.plan || !title) {
+        throw new Error(`${file} needs a plan, and a title in the file or as --title (docs/working/plan-surfaces.md).`);
+    }
+    const client = solutionClient();
+    const id = await client.mutation(api.solutions.mutations.create, {
+        project: client.project,
+        title,
+        description: described ??
+            (typeof spec.description === "string" ? spec.description : undefined),
+        // PLAN-1: the plan as the file writes it; the backend reads it.
+        plan: planPayload(spec),
+        inputs: Array.isArray(spec.inputs) ? spec.inputs : [],
+        idea,
+    });
+    console.log(`Created "${title}": ${id}`);
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/solution/demo-script.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where a demo's script is saved in the checkout of the agent reviewing it
+ * (SIGHT-13.1), relative to the repository's root: the folder git ignores,
+ * under the script's file name. Kept in step with the backend's
+ * `demoScriptCopyPath` (convex/solutions/brief.ts), which is where the brief
+ * says the copy is.
+ */
+export declare function demoScriptCopyPath(name: string): string;
+/** An outcome as `dotreq solution next` returns it, as far as this reads it. */
+type BriefOutcome = {
+    things?: Array<{
+        kind: string;
+        name?: string;
+        script?: string;
+    }>;
+};
+/**
+ * Save a copy of each demo's script among the outcomes a reviewer reads in
+ * its checkout, where its brief says it is, so it records the video from
+ * that file and fixes anything small there first (SIGHT-13.1, 13.3). The
+ * drafter's latest script replaces any earlier copy, as when the drafter
+ * revised it. The folder ignores itself, so nothing saved there is ever
+ * committed (13.0). The review is already started, so a copy that can't be
+ * saved is said on stderr rather than failing the run.
+ */
+export declare function saveDemoScriptCopies(outcomes: readonly BriefOutcome[], cwd?: string): void;
+export {};
+//# sourceMappingURL=demo-script.d.ts.map

package/dist/commands/solution/demo-script.js

@@ -0,0 +1,43 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { repositoryRoot } from "./branch.js";
+/**
+ * Where a demo's script is saved in the checkout of the agent reviewing it
+ * (SIGHT-13.1), relative to the repository's root: the folder git ignores,
+ * under the script's file name. Kept in step with the backend's
+ * `demoScriptCopyPath` (convex/solutions/brief.ts), which is where the brief
+ * says the copy is.
+ */
+export function demoScriptCopyPath(name) {
+    return `.dotreq/demo-scripts/${name}`;
+}
+/**
+ * Save a copy of each demo's script among the outcomes a reviewer reads in
+ * its checkout, where its brief says it is, so it records the video from
+ * that file and fixes anything small there first (SIGHT-13.1, 13.3). The
+ * drafter's latest script replaces any earlier copy, as when the drafter
+ * revised it. The folder ignores itself, so nothing saved there is ever
+ * committed (13.0). The review is already started, so a copy that can't be
+ * saved is said on stderr rather than failing the run.
+ */
+export function saveDemoScriptCopies(outcomes, cwd = process.cwd()) {
+    const scripts = outcomes.flatMap((outcome) => (outcome.things ?? []).flatMap((thing) => thing.kind === "demo script" && thing.name && thing.script !== undefined
+        ? [{ name: basename(thing.name), script: thing.script }]
+        : []));
+    if (scripts.length === 0)
+        return;
+    const root = repositoryRoot(cwd) ?? cwd;
+    try {
+        mkdirSync(join(root, ".dotreq"), { recursive: true });
+        writeFileSync(join(root, ".dotreq", ".gitignore"), "*\n");
+        for (const { name, script } of scripts) {
+            const path = join(root, demoScriptCopyPath(name));
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, script);
+        }
+    }
+    catch (error) {
+        console.error(`Couldn't save a copy of the demo's script: ${error instanceof Error ? error.message : String(error)}. Its text is in your brief.`);
+    }
+}
+//# sourceMappingURL=demo-script.js.map

package/dist/commands/solution/image.d.ts

@@ -0,0 +1,60 @@
+import type { solutionClient } from "./client.js";
+/**
+ * Images on an outcome (SIGHT-9), such as a screenshot: the drafter submits an
+ * image file from its checkout or anywhere it can read, and the app keeps a
+ * copy; nothing is committed.
+ *
+ * Every browser we support (Chrome, Edge, Firefox, Safari on macOS and iOS)
+ * shows PNG, JPEG, GIF, WebP and AVIF (MDN's image type guide; AVIF from
+ * Safari 16.4). HEIC and TIFF show only in Safari, and JPEG XL not in Edge,
+ * so they are refused. SVG is refused too: opened at full size in its own
+ * tab, an SVG runs whatever script it carries. The format is read from the
+ * file's first bytes (the WHATWG MIME Sniffing signatures; AVIF's brand in
+ * its `ftyp` box), since an extension says nothing about it. Kept in step
+ * with the backend's `ACCEPTED_IMAGE_FORMATS` (convex/solutions/images.ts).
+ */
+export declare const ACCEPTED_IMAGE_FORMATS = "a PNG, JPEG, GIF, WebP or AVIF image";
+export type ImageContentType = "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/avif";
+/** What the file is: a format a browser shows, or why it isn't one. */
+export type ImageFormat = {
+    contentType: ImageContentType;
+} | {
+    refused: string;
+};
+/** An image read from the checkout, ready to upload. */
+export type Image = {
+    name: string;
+    contentType: ImageContentType;
+    bytes: Uint8Array<ArrayBuffer>;
+};
+/** The image at a path, or a refusal naming the accepted formats (SIGHT-9.0.0). */
+export declare function readImage(path: string): Image;
+/** What image format the bytes hold, read from the file's signature. */
+export declare function imageFormat(bytes: Uint8Array): ImageFormat;
+/**
+ * Where an image's copy is saved in the checkout, relative to the
+ * repository's root (SIGHT-9.3): a folder git ignores, then one folder per
+ * stored copy, so two images of one name stay apart. Kept in step with the
+ * backend's `imageCopyPath` (convex/solutions/brief.ts), which is where
+ * the brief says the copy is.
+ */
+export declare function imageCopyPath(storageId: string, name: string): string;
+/** An outcome as `dotreq solution next` returns it, as far as this reads it. */
+type BriefOutcome = {
+    things?: Array<{
+        kind: string;
+        storageId?: string;
+    }>;
+};
+/**
+ * Save a copy of each image among the outcomes an agent works on in the
+ * checkout, where its brief says it is (SIGHT-9.3), in place of the copies
+ * an earlier session saved. The folder ignores itself, so nothing saved
+ * there is ever committed (9.0). The work is already started, so a copy
+ * that can't be saved is said on stderr rather than failing the run.
+ */
+export declare function saveImageCopies(client: ReturnType<typeof solutionClient>, solutionId: string, outcomes: readonly BriefOutcome[], cwd?: string): Promise<void>;
+/** Upload an image to the app (SIGHT-9.0), and the stored copy's id back. */
+export declare function uploadImage(client: ReturnType<typeof solutionClient>, solutionId: string, image: Image): Promise<string>;
+export {};
+//# sourceMappingURL=image.d.ts.map