@popoverai/dotrequirements 0.33.0 → 0.34.0

package/dist/commands/scores/index.js

@@ -0,0 +1,190 @@
+import { readFileSync } from "node:fs";
+import { api } from "../../convex.js";
+import { solutionClient } from "../solution/client.js";
+/**
+ * Hidden from help until solutions launch: today's users see the CLI they
+ * have now, and the server refuses these commands for a team without the
+ * solutions switch (SOLACCESS-2).
+ */
+const HIDDEN_UNTIL_LAUNCH = { hidden: true };
+/**
+ * Scores from the shell (VERB-7, SCORES-1): a solution's price on CREATED's
+ * seven axes, made with `create` and revised with `update`, each axis a
+ * whole number from 1 to 5 with a reason. Like a board or a mockup, scores
+ * are a thing: `create` prints the `scores:<id>` a writer submits with
+ * `dotreq solution author`, whose comment says what changed and why.
+ * Nothing reaches the backend unless every axis is whole, and the backend
+ * refuses the same again.
+ */
+/**
+ * The seven axes as `dotreq scores` takes them (VERB-7): the key the backend stores,
+ * the name a person reads, and the option, which is also how a line of the
+ * reasons file names the axis. The backend's own list is
+ * packages/convex/solutions/scores.ts; the CLI can't import it, so a test
+ * keeps the two equal.
+ */
+export const AXES = [
+    { key: "costOfDelay", label: "Cost of delay", option: "cost-of-delay" },
+    { key: "relevance", label: "Relevance", option: "relevance" },
+    { key: "entities", label: "Entities", option: "entities" },
+    { key: "api", label: "API", option: "api" },
+    { key: "testing", label: "Testing", option: "testing" },
+    { key: "experience", label: "Experience", option: "experience" },
+    { key: "doubt", label: "Doubt", option: "doubt" },
+];
+const AXIS_NAMES = `The axes are ${AXES.map((axis) => axis.option).join(", ")}.`;
+/** Each axis's score from its option, or a refusal naming the axis (VERB-7.2). */
+function scoresFrom(options) {
+    const scores = {};
+    for (const axis of AXES) {
+        const given = options[axis.key]?.trim();
+        if (!given) {
+            throw new Error(`${axis.label} has no score: give it with --${axis.option} <1-5>.`);
+        }
+        const score = Number(given);
+        if (!/^\d+$/.test(given) || score < 1 || score > 5) {
+            throw new Error(`${axis.label} is scored "${given}": a score is a whole number from 1 to 5.`);
+        }
+        scores[axis.key] = score;
+    }
+    return scores;
+}
+/**
+ * Each axis's reason from the reasons file (VERB-7.0): one line an axis,
+ * `<axis>: <reason>`, the axis spelled as its option is, in any case; a
+ * leading "- " and blank lines are passed over. Refuses a line in another
+ * form, an axis that isn't one of the seven or is named twice (VERB-7.3),
+ * and an axis with no reason (VERB-7.2).
+ */
+export function reasonsFrom(text, file) {
+    const reasons = {};
+    const lines = text.split(/\r?\n/);
+    lines.forEach((raw, index) => {
+        const line = raw.trim().replace(/^-\s+/, "");
+        if (!line)
+            return;
+        const colon = line.indexOf(":");
+        if (colon === -1) {
+            throw new Error(`Line ${index + 1} of ${file} isn't "<axis>: <reason>": "${raw.trim()}". ${AXIS_NAMES}`);
+        }
+        const name = line.slice(0, colon).trim().toLowerCase();
+        const axis = AXES.find((a) => a.option === name);
+        if (!axis) {
+            throw new Error(`"${name}" in ${file} isn't an axis. ${AXIS_NAMES}`);
+        }
+        if (reasons[axis.key] !== undefined) {
+            throw new Error(`"${name}" is named twice in ${file}. ${AXIS_NAMES}`);
+        }
+        reasons[axis.key] = line.slice(colon + 1).trim();
+    });
+    for (const axis of AXES) {
+        if (!reasons[axis.key]) {
+            throw new Error(`${axis.label} has no reason: add the line "${axis.option}: <why>" to ${file}.`);
+        }
+    }
+    return reasons;
+}
+/** The seven axes, checked, from the options and the reasons file. */
+function axesFrom(options) {
+    const scores = scoresFrom(options);
+    const file = options.reasons?.trim();
+    if (!file) {
+        throw new Error(`Give each axis's reason in a file: --reasons <file>, one line per axis, "<axis>: <reason>". ${AXIS_NAMES}`);
+    }
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        throw new Error(`Can't read the reasons file ${file}.`);
+    }
+    const reasons = reasonsFrom(text, file);
+    return Object.fromEntries(AXES.map((axis) => [
+        axis.key,
+        { score: scores[axis.key], reason: reasons[axis.key] },
+    ]));
+}
+/** `dotreq scores create`: new scores, and the reference to record them by (VERB-7.0). */
+export async function createCommand(options) {
+    const axes = axesFrom(options);
+    const client = solutionClient();
+    const { scoresId } = await client.mutation(api.scores.mutations.create, { project: client.project, ...axes });
+    console.log(`Created scores ${scoresId}. Record them with: dotreq solution author scores:${scoresId} --comment "..."`);
+}
+/** `dotreq scores update <id>`: all seven axes again, for a revision (VERB-7.1). */
+export async function updateCommand(scoresId, options) {
+    const axes = axesFrom(options);
+    // Named by its id or by the reference `create` printed.
+    const id = scoresId.replace(/^scores:/, "");
+    await solutionClient().mutation(api.scores.mutations.update, {
+        scoresId: id,
+        ...axes,
+    });
+    console.log(`Updated scores ${id}. Record the revision with: dotreq solution author scores:${id} --comment "..."`);
+}
+/** The axes, the reasons file and an example, on `scores --help` (VERB-7.4). */
+export const SCORES_HELP = `
+Scores are seven axes, each a whole number from 1 to 5 with one line of reasoning:
+  suitability, whether to do this now:
+    --cost-of-delay, --relevance
+  appetite, what it takes to build and how likely the other six are wrong:
+    --entities, --api, --testing, --experience, --doubt
+
+The reasons file has one line per axis, the axis named as its option is,
+without the dashes:
+  cost-of-delay: <why this score>
+  relevance: <why>
+  entities: <why>
+  api: <why>
+  testing: <why>
+  experience: <why>
+  doubt: <why>
+
+create prints the scores' reference; record them with it, as any work is
+recorded. To revise them, update them with all seven axes again and record
+them again.
+
+Examples:
+  dotreq scores create --cost-of-delay 4 --relevance 3 --entities 2 --api 2 \\
+    --testing 2 --experience 3 --doubt 2 --reasons reasons.txt
+  dotreq solution author scores:<id> --comment "Scored against the pitch's draft and the discovery board."
+  dotreq scores update <id> --cost-of-delay 4 --relevance 3 --entities 3 --api 2 \\
+    --testing 2 --experience 3 --doubt 3 --reasons reasons.txt
+`;
+/** The seven axis options and the reasons file, on both subcommands. */
+function axisOptions(command) {
+    return command
+        .option("--cost-of-delay <n>", "Cost of delay, 1 to 5")
+        .option("--relevance <n>", "Relevance, 1 to 5")
+        .option("--entities <n>", "Entities, 1 to 5")
+        .option("--api <n>", "API, 1 to 5")
+        .option("--testing <n>", "Testing, 1 to 5")
+        .option("--experience <n>", "Experience, 1 to 5")
+        .option("--doubt <n>", "Doubt, 1 to 5")
+        .option("--reasons <file>", "A file with one line per axis, <axis>: <reason> (required)")
+        .addHelpText("after", SCORES_HELP);
+}
+export function registerScores(program) {
+    const scores = program
+        .command("scores", HIDDEN_UNTIL_LAUNCH)
+        .description("Make and revise a solution's scores: seven axes, each a whole number from 1 to 5 with a reason")
+        .addHelpText("after", SCORES_HELP);
+    axisOptions(scores
+        .command("create")
+        .description("Make scores from the seven axis options and a reasons file, and print the reference to record them by")).action(wrap(createCommand));
+    axisOptions(scores
+        .command("update <scores>")
+        .description("Revise scores, named by their id or scores:<id>, with all seven axes again; record them again with author")).action(wrap(updateCommand));
+}
+function wrap(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (error) {
+            console.error(`\nError: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 1;
+        }
+    };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+import { type WhereOptions } from "./run-file.js";
+/**
+ * `dotreq solution ask <request-file>`: the drafter puts a decision to the
+ * owner, on the outcome it is drafting or the one `--outcome` names. A
+ * reviewer escalates instead (`dotreq solution review escalate`), and the
+ * backend refuses its question (VERB-3.5).
+ */
+export declare function askCommand(file: string, options: WhereOptions): Promise<void>;
+//# sourceMappingURL=ask.d.ts.map

package/dist/commands/solution/ask.js

@@ -0,0 +1,27 @@
+import { api } from "../../convex.js";
+import { solutionClient } from "./client.js";
+import { pushBeforeRecord } from "./pushing.js";
+import { readRequest } from "./request.js";
+import { onOutcome, requireWhere } from "./run-file.js";
+/**
+ * `dotreq solution ask <request-file>`: the drafter puts a decision to the
+ * owner, on the outcome it is drafting or the one `--outcome` names. A
+ * reviewer escalates instead (`dotreq solution review escalate`), and the
+ * backend refuses its question (VERB-3.5).
+ */
+export async function askCommand(file, options) {
+    const request = readRequest(file);
+    const where = requireWhere(options);
+    const { solutionId, agent } = where;
+    const client = solutionClient();
+    // SOLBRANCH-3.0: the drafter's commits reach the branch before Quinn is asked.
+    await pushBeforeRecord(client, where);
+    await client.mutation(api.solutions.mutations.ask, {
+        solutionId,
+        agent,
+        ...(where.outcome ? { outcome: where.outcome } : {}),
+        request,
+    });
+    console.log(`Asked${onOutcome(where.outcome)}. It waits on the owner's decision.`);
+}
+//# sourceMappingURL=ask.js.map

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

@@ -0,0 +1,19 @@
+import { type WhereOptions } from "./run-file.js";
+import { type SummaryOptions } from "./summary.js";
+export type AuthorOptions = WhereOptions & SummaryOptions & {
+    /** What changed and why, for the outcome's thread (VERB-1.1, STEP-REVIEW-5.0). */
+    comment?: string;
+    /** Each reference's name on the outcome's tab: one per reference, in their order, or none (SIGHT-12.3). */
+    title?: string[];
+};
+/**
+ * `dotreq solution author <reference>... --comment "<what changed and why>"`:
+ * the drafter's submission of the outcome it is drafting, or of the one
+ * `--outcome` names. The references say where what it made is; the comment
+ * is what the next reader of the thread sees first, so nothing is recorded
+ * without it (VERB-1.2). On an outcome no agent reviews, the work goes to
+ * the owner with the executive summary, `--executive-summary "..."`, which
+ * the backend asks for there (VERB-1.6).
+ */
+export declare function authorCommand(references: string[], options: AuthorOptions): Promise<void>;
+//# sourceMappingURL=author.d.ts.map

package/dist/commands/solution/author.js

@@ -0,0 +1,202 @@
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { api } from "../../convex.js";
+import { currentBranch, headCommit, repositoryRoot } from "./branch.js";
+import { solutionClient } from "./client.js";
+import { readImage, uploadImage } from "./image.js";
+import { screenshotPreview } from "./preview-screenshot.js";
+import { checkPullRequest } from "./pull-request.js";
+import { pushBeforeRecord, refuseUncommitted } from "./pushing.js";
+import { onOutcome, requireWhere } from "./run-file.js";
+import { summaryGiven } from "./summary.js";
+import { parseThing, REFERENCE_FORMS } from "./things.js";
+import { readDemoScript, readRecording, submittedRecording, } from "./video.js";
+import { readSubmittedFiles, recordSavedIds, } from "./working-folder.js";
+/**
+ * `dotreq solution author <reference>... --comment "<what changed and why>"`:
+ * the drafter's submission of the outcome it is drafting, or of the one
+ * `--outcome` names. The references say where what it made is; the comment
+ * is what the next reader of the thread sees first, so nothing is recorded
+ * without it (VERB-1.2). On an outcome no agent reviews, the work goes to
+ * the owner with the executive summary, `--executive-summary "..."`, which
+ * the backend asks for there (VERB-1.6).
+ */
+export async function authorCommand(references, options) {
+    if (references.length === 0) {
+        throw new Error("Name where what you made is: dotreq solution author <reference>... — `dotreq solution author --help` gives the forms.");
+    }
+    const comment = options.comment?.trim();
+    if (!comment) {
+        throw new Error("Say what changed and why: your comment is what the next reader sees first.");
+    }
+    const where = requireWhere(options);
+    const made = references.map(parseThing);
+    // SIGHT-12.3, 12.3.0: each reference's title, matched to it by order
+    // before anything is read, pushed, uploaded or recorded.
+    const titles = titleReferences(made, options.title ?? []);
+    // SIGHT-7.0.0, 7.0.1, 9.0.0, 13.0: a video and its script, a demo's
+    // script, and an image, are read first, so one a browser can't show, or
+    // a script that isn't one, is refused before anything is pushed,
+    // uploaded or recorded.
+    const videos = new Map();
+    const demoScripts = new Map();
+    const images = new Map();
+    for (const thing of made) {
+        if (thing.kind === "video") {
+            videos.set(thing, readRecording(thing.path, thing.scriptPath));
+        }
+        if (thing.kind === "demo script") {
+            demoScripts.set(thing, readDemoScript(thing.path));
+        }
+        if (thing.kind === "image")
+            images.set(thing, readImage(thing.path));
+    }
+    // VERB-1.4, 1.5: a file named without its branch is on the branch the
+    // checkout is on, or on none.
+    const cwd = process.cwd();
+    refuseOutsideCheckout(made, cwd);
+    const checkout = currentBranch(cwd);
+    const fromCheckout = (thing) => thing.kind === "file" &&
+        (thing.branch === undefined || thing.branch === checkout);
+    // PULL-3.0, 3.2: the pull request named is the solution's, open from its
+    // branch, checked before anything is pushed or recorded.
+    const pullRequests = new Map();
+    for (const thing of made) {
+        if (thing.kind === "pull request") {
+            pullRequests.set(thing, await checkPullRequest(where, thing.number));
+        }
+    }
+    const client = solutionClient();
+    if (where.branch) {
+        // Inside a runner: only what is committed is submitted (SOLBRANCH-5),
+        // and it reaches the solution's branch before the record is kept (3.0).
+        refuseUncommitted({ ...where, branch: where.branch }, made.flatMap((thing) => fromCheckout(thing) && thing.kind === "file" ? [thing.path] : []));
+        await pushBeforeRecord(client, where);
+    }
+    // SOLDOC-12.2.0: a file from the checkout's own branch keeps the commit
+    // it was submitted at, so the page can tell when it changes after.
+    const commit = checkout ? headCommit(cwd) : null;
+    /** A reference as it is submitted: where the thing is, as the backend keeps it. */
+    const submissionOf = async (thing) => {
+        const recording = videos.get(thing);
+        if (recording) {
+            // SIGHT-7.0, 7.4: the app keeps a copy of the video, the script's
+            // text and where each of its steps begins; nothing goes on the
+            // branch.
+            return submittedRecording(client, where.solutionId, recording);
+        }
+        const demoScript = demoScripts.get(thing);
+        if (demoScript) {
+            // SIGHT-13.0: the app keeps the script's text for the agent
+            // reviewing it to record; nothing goes on the branch.
+            return { kind: "demo script", ...demoScript };
+        }
+        const image = images.get(thing);
+        if (image) {
+            // SIGHT-9.0: the app keeps a copy of the image; nothing goes on the
+            // branch.
+            const storageId = await uploadImage(client, where.solutionId, image);
+            return { kind: "image", storageId, name: image.name };
+        }
+        const pullRequest = pullRequests.get(thing);
+        if (pullRequest)
+            return { kind: "pull request", ...pullRequest };
+        if (thing.kind === "preview") {
+            // SIGHT-12.0, 12.2: a screenshot of the page it opens on, kept as an
+            // image is; without one, it is submitted all the same.
+            const shot = await screenshotPreview(thing);
+            if ("image" in shot) {
+                const screenshot = await uploadImage(client, where.solutionId, shot.image);
+                return { ...thing, screenshot };
+            }
+            console.error(`No screenshot of preview:${thing.port}${thing.page ?? ""} was taken (${shot.missed}); its tab says so. Submit it again once it answers to add one.`);
+            return thing;
+        }
+        return checkout && fromCheckout(thing)
+            ? { ...thing, branch: checkout, ...(commit ? { commit } : {}) }
+            : thing;
+    };
+    const submitted = [];
+    for (const thing of made) {
+        // SIGHT-12.3: the title given for it goes with it, whatever its kind.
+        const title = titles.get(thing);
+        submitted.push({
+            ...(await submissionOf(thing)),
+            ...(title ? { title } : {}),
+        });
+    }
+    // A document submitted by its file goes with its text when there is no
+    // git checkout: on a project with no repository connected, the backend
+    // saves it on the solution's branch (BRANCH-1.0).
+    const files = checkout ? [] : readSubmittedFiles(made);
+    // VERB-1.6: on an outcome no agent reviews, the owner reads the executive
+    // summary first. Only the backend knows whether one does, so it is the
+    // backend that refuses the work without one.
+    const summary = summaryGiven(options);
+    const args = {
+        solutionId: where.solutionId,
+        agent: where.agent,
+        ...(where.outcome ? { outcome: where.outcome } : {}),
+        made: submitted,
+        comment,
+        ...(summary ? { summary } : {}),
+        ...(files.length ? { files } : {}),
+    };
+    const result = await client.mutation(api.solutions.mutations.complete, args);
+    const saved = result?.saved ?? [];
+    recordSavedIds(files, saved);
+    for (const entry of saved) {
+        console.log(`Saved ${entry.path} on the solution's branch as version ${entry.version}.`);
+    }
+    // CHECKPOINT-6.3.2.3: work begun before the outcome was set to be
+    // drafted again is kept, but isn't its new draft; the agent is told so.
+    if (result?.setAside) {
+        console.log(result.setAside);
+        return;
+    }
+    console.log(`Recorded your work${onOutcome(where.outcome)}.`);
+}
+/**
+ * SOLBRANCH-5.3: a file is submitted by where it is in the repository, so
+ * one from outside the checkout, such as a video written under /tmp, would
+ * be recorded at a path nobody can open. Refused, with the other forms, so
+ * the agent finds the one it meant.
+ */
+function refuseOutsideCheckout(made, cwd) {
+    const root = repositoryRoot(cwd);
+    if (!root)
+        return;
+    const top = realpathSync(root);
+    const here = realpathSync(cwd);
+    const outside = made.flatMap((thing) => {
+        if (thing.kind !== "file")
+            return [];
+        const within = relative(top, resolve(here, thing.path));
+        return within.startsWith("..") || isAbsolute(within) ? [thing.path] : [];
+    });
+    if (outside.length === 0)
+        return;
+    throw new Error(`Nothing was recorded: ${outside.join(", ")} ${outside.length === 1 ? "is" : "are"} outside your checkout, and only files in the repository are submitted as files. ${REFERENCE_FORMS}`);
+}
+/**
+ * SIGHT-12.3, 12.3.0, 12.3.1: the title each reference is submitted with,
+ * its name on the outcome's tab, given as one `--title` per reference in the
+ * order the references are named, as `git commit -m` takes one per
+ * paragraph. None given, each keeps the name the tab gives it; a count that
+ * doesn't match submits nothing. A blank title is none, for that reference
+ * alone.
+ */
+function titleReferences(made, given) {
+    if (given.length > 0 && given.length !== made.length) {
+        const count = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+        throw new Error(`You named ${count(made.length, "reference", "references")} and gave ${count(given.length, "--title", "--titles")}, so nothing was submitted. Give one --title per reference, in the order you name them, or none.`);
+    }
+    const titles = new Map();
+    given.forEach((text, at) => {
+        const title = text.trim();
+        if (title)
+            titles.set(made[at], title);
+    });
+    return titles;
+}
+//# sourceMappingURL=author.js.map

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

@@ -0,0 +1,103 @@
+/**
+ * The git a solution's branch needs (SOLBRANCH): which branch a checkout
+ * is on, what it has not committed, bringing the branch's new commits in
+ * under the agent's own, and pushing. Every function runs git in the
+ * directory it is given and never commits: what an agent has not committed
+ * stays uncommitted, in its checkout (SOLBRANCH-6).
+ */
+type Ran = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function git(cwd: string, args: string[]): Ran;
+/** Git's name for no commit: a push's `before` when the branch wasn't in the repository. */
+export declare const NO_COMMIT = "0000000000000000000000000000000000000000";
+/**
+ * The branch the checkout is on, or null when it is on no branch — a
+ * single commit checked out, or no git repository at all (VERB-1.4, 1.5).
+ */
+export declare function currentBranch(cwd: string): string | null;
+/** The top of the repository the checkout is in, or null outside one. */
+export declare function repositoryRoot(cwd: string): string | null;
+/** The commit the checkout is at, or null outside a git repository. */
+export declare function headCommit(cwd: string): string | null;
+/**
+ * What the checkout has not committed: files git tracks with changes,
+ * staged or not, and new files it does not ignore, one by one.
+ */
+export declare function uncommitted(cwd: string): {
+    changed: string[];
+    untracked: string[];
+};
+export type BroughtIn = {
+    ok: true;
+} | {
+    ok: false;
+    conflicts: string[];
+} | {
+    ok: false;
+    problem: string;
+};
+/**
+ * Bring the branch's new commits into the checkout, the agent's own
+ * commits placed after them (SOLBRANCH-2, 3.1). When they conflict — with
+ * a commit of the agent's, or with a change it has not committed — the
+ * checkout is left exactly as it was, and the files that conflict are
+ * named (SOLBRANCH-2.3, 3.2). What it has not committed stays uncommitted.
+ */
+export declare function bringIn(cwd: string, branch: string): BroughtIn;
+export type Pushed = {
+    kind: "pushed";
+    before: string;
+    after: string;
+} | {
+    kind: "nothing to push";
+} | {
+    kind: "conflict";
+    files: string[];
+} | {
+    kind: "refused";
+    reason: string;
+};
+/**
+ * Push the checkout's commits to the solution's branch, after bringing in
+ * what other agents pushed since (SOLBRANCH-3.1). A push that loses a race
+ * with another agent's tries again; one the repository refuses comes back
+ * with the reason it gave (3.3).
+ */
+export declare function pushTo(cwd: string, branch: string): Pushed;
+/** The names of the repository's branches, as it has them now. */
+export declare function remoteBranches(cwd: string): Set<string>;
+/**
+ * The name for a solution's new branch: `dotreq/<directory>`, or, when a
+ * branch already has that name, the lowest suffix from -2 up that none has
+ * (SOLBRANCH-1.0, 1.1).
+ */
+export declare function freeName(directory: string, taken: Set<string>): string;
+/** The default branch's commit, as the repository has it now, fetched into the checkout. */
+export declare function defaultBranchCommit(cwd: string): string;
+/**
+ * The commit a named branch is at, as the repository has it now, fetched
+ * into the checkout: what a solution's branch is made from when a
+ * rehearsal's scenario names the branch to start from (REHEARSE-4.5).
+ */
+export declare function branchCommit(cwd: string, branch: string): string;
+/**
+ * The commit the repository's branch `name` is at, making the branch at
+ * `base` first when the repository has none of that name (SOLBRANCH-1.0,
+ * 1.3). A branch of that name that appears first — another of the
+ * solution's first sessions making it a moment before, or anyone's — is
+ * never moved: its commit is read and returned, for the caller to judge
+ * whose it is.
+ */
+export declare function branchHead(cwd: string, name: string, base: string): string;
+/**
+ * Put the checkout on the solution's branch, and bring in what other steps
+ * pushed to it (SOLBRANCH-1.2, 2). Returns what the agent should be told,
+ * or null when there is nothing to tell: its checkout is on the branch and
+ * holds everything pushed to it.
+ */
+export declare function checkOut(cwd: string, branch: string): string | null;
+export {};
+//# sourceMappingURL=branch.d.ts.map