@popoverai/dotrequirements 0.33.0 → 0.34.1

package/dist/commands/solution/video.js

@@ -0,0 +1,364 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { api } from "../../convex.js";
+import { uploadToApp } from "./upload.js";
+/**
+ * Videos on an outcome (SIGHT-7): the drafter submits a video file from its
+ * checkout with the script it was recorded from. The video is uploaded to
+ * the app and never committed; the script travels as text, and the outcome's
+ * reviewer reads it in its brief.
+ *
+ * A browser plays MP4 with H.264 video and WebM with VP8 or VP9 video
+ * everywhere we support (Chrome, Edge, Firefox, Safari on macOS and iOS).
+ * HEVC and AV1 play only on some hardware, and QuickTime and Matroska only
+ * in some browsers, so they are refused. The codec is read from the file
+ * itself, since an extension says nothing about it. Kept in step with the
+ * backend's `ACCEPTED_VIDEO_FORMATS` (convex/solutions/videos.ts).
+ */
+export const ACCEPTED_VIDEO_FORMATS = "an MP4 with H.264 video, or a WebM with VP8 or VP9 video";
+/** The video at a path, or a refusal naming the accepted formats (SIGHT-7.0.0). */
+export function readVideo(path) {
+    const full = resolve(path);
+    if (!existsSync(full) || !statSync(full).isFile()) {
+        throw new Error(`There is no file at ${path}, so nothing was submitted.`);
+    }
+    const bytes = new Uint8Array(readFileSync(full));
+    const format = videoFormat(bytes);
+    if ("refused" in format) {
+        throw new Error(`${path} isn't a video a browser can play (${format.refused}), so nothing was submitted. Submit ${ACCEPTED_VIDEO_FORMATS}.`);
+    }
+    return { name: basename(full), contentType: format.contentType, bytes };
+}
+/**
+ * The script a video was recorded from (SIGHT-7.0, 7.0.1): agentic-demo's
+ * steps file, JSON holding the browser commands for each step and the
+ * sentence said over it, as its text. Anything else is refused, so a
+ * reviewer never reads the wrong file as the demo's script.
+ */
+export function readScript(path) {
+    const full = resolve(path);
+    if (!existsSync(full) || !statSync(full).isFile()) {
+        throw new Error(`There is no script at ${path}, so nothing was submitted. Submit the steps file the video was recorded from with it.`);
+    }
+    const text = readFileSync(full, "utf8");
+    if (!isStepsFile(text)) {
+        throw new Error(`${path} isn't the steps file a video is recorded from, so nothing was submitted. Submit the steps file you recorded the video from, with its steps and what is said over each.`);
+    }
+    return text;
+}
+/**
+ * Where each step of the script begins in the video, in seconds
+ * (SIGHT-7.4): read from the summary `agentic-demo record` writes beside
+ * the video it records, `final.json` (@popoverai/browser-automation 0.15.4
+ * on), one segment per step: `index`, the step's 0-based place in the steps
+ * file, and `startSeconds`, where the step's first frame is in the final
+ * video, taken as given. The starts are kept in the steps file's order, so
+ * step n of a link, counted from 1 as the recorder prints it ("step 1/6"),
+ * is the start at n − 1 (SOLDOC-15.1.1). None when there is no such file,
+ * as beside a video recorded before the recorder wrote one, so a link to a
+ * step of the script opens the video at its start (SOLDOC-15.1.1.0); none,
+ * with a word on stderr, when the file isn't the recorder's summary of this
+ * script, one start for each of its steps.
+ */
+export function readStepStarts(videoPath, script) {
+    const summary = join(dirname(resolve(videoPath)), "final.json");
+    if (!existsSync(summary))
+        return undefined;
+    let segments;
+    try {
+        segments = JSON.parse(readFileSync(summary, "utf8"))?.segments;
+    }
+    catch {
+        segments = undefined;
+    }
+    const starts = [];
+    if (Array.isArray(segments)) {
+        segments.forEach((segment, at) => {
+            const index = Number.isInteger(segment?.index)
+                ? segment.index
+                : at;
+            starts[index] = segment?.startSeconds;
+        });
+    }
+    const steps = JSON.parse(script).steps.length;
+    const fits = starts.length === steps &&
+        // Array.from gives a step no segment named `undefined`, which fails.
+        Array.from(starts).every((start) => typeof start === "number" && Number.isFinite(start) && start >= 0);
+    if (!fits) {
+        console.error(`${summary} doesn't give where each of the script's ${steps} steps begins, so the video is submitted without them; a link to a step of it opens at its start. Record it again from this script to keep them.`);
+        return undefined;
+    }
+    return starts;
+}
+/**
+ * A demo's script, as the drafter submits it (SIGHT-13.0): the steps file
+ * the agent reviewing it records the video from, as its text.
+ */
+export function readDemoScript(path) {
+    const full = resolve(path);
+    if (!existsSync(full) || !statSync(full).isFile()) {
+        throw new Error(`There is no demo script at ${path}, so nothing was submitted. Submit the steps file the demo is recorded from, as demo-script:<steps file>.`);
+    }
+    const script = readFileSync(full, "utf8");
+    if (!isStepsFile(script)) {
+        throw new Error(`${path} isn't a steps file a demo is recorded from, so nothing was submitted. Submit the steps file with its steps and what is said over each; \`agentic-demo validate ${path}\` checks it.`);
+    }
+    return { name: basename(full), script };
+}
+/** JSON with a list of steps, each saying what is said over it. */
+function isStepsFile(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return false;
+    }
+    const steps = parsed?.steps;
+    return (Array.isArray(steps) &&
+        steps.length > 0 &&
+        steps.every((step) => typeof step?.narrate === "string"));
+}
+/** What container and video codec the bytes hold, read from the file itself. */
+export function videoFormat(bytes) {
+    if (fourcc(bytes, 4) === "ftyp")
+        return mp4Format(bytes);
+    if (readUint(bytes, 0, 4) === 0x1a45dfa3)
+        return webmFormat(bytes);
+    return { refused: "it isn't an MP4 or a WebM file" };
+}
+// ---------------------------------------------------------------------------
+// MP4: a tree of boxes, each a 32-bit size and a four-letter type. The video
+// track's codec is the first sample entry of its `stsd`, under
+// moov > trak > mdia > minf > stbl, and a track is video when its `hdlr`
+// says `vide`.
+const H264 = new Set(["avc1", "avc3"]);
+const MP4_CODEC_NAMES = {
+    hvc1: "HEVC",
+    hev1: "HEVC",
+    av01: "AV1",
+    vp09: "VP9 in an MP4",
+    vp08: "VP8 in an MP4",
+    mp4v: "MPEG-4 Part 2",
+};
+function mp4Format(bytes) {
+    const top = boxes(bytes, 0, bytes.length);
+    if (!top)
+        return { refused: "its MP4 structure is damaged" };
+    const ftyp = top.find((box) => box.type === "ftyp");
+    if (ftyp && fourcc(bytes, ftyp.body) === "qt  ") {
+        return { refused: "it is a QuickTime movie" };
+    }
+    const moov = top.find((box) => box.type === "moov");
+    if (!moov)
+        return { refused: "it has no movie header" };
+    const codecs = [];
+    for (const trak of children(bytes, moov, "trak")) {
+        const mdia = children(bytes, trak, "mdia")[0];
+        if (!mdia)
+            continue;
+        const hdlr = children(bytes, mdia, "hdlr")[0];
+        // hdlr: version and flags, pre_defined, then the handler type.
+        if (!hdlr || fourcc(bytes, hdlr.body + 8) !== "vide")
+            continue;
+        const minf = children(bytes, mdia, "minf")[0];
+        const stbl = minf && children(bytes, minf, "stbl")[0];
+        const stsd = stbl && children(bytes, stbl, "stsd")[0];
+        if (!stsd)
+            continue;
+        // stsd: version and flags, an entry count, then the entries as boxes.
+        const entries = boxes(bytes, stsd.body + 8, stsd.end);
+        if (entries?.[0])
+            codecs.push(entries[0].type);
+    }
+    if (codecs.length === 0)
+        return { refused: "it has no video track" };
+    const other = codecs.find((codec) => !H264.has(codec));
+    if (other) {
+        return { refused: `its video is ${MP4_CODEC_NAMES[other] ?? other}` };
+    }
+    return { contentType: "video/mp4" };
+}
+function children(bytes, parent, type) {
+    return (boxes(bytes, parent.body, parent.end) ?? []).filter((box) => box.type === type);
+}
+/** The boxes between two offsets, or null when a size runs past the end. */
+function boxes(bytes, start, end) {
+    const found = [];
+    let at = start;
+    while (at + 8 <= end) {
+        let size = readUint(bytes, at, 4);
+        let header = 8;
+        if (size === 1) {
+            if (at + 16 > end)
+                return null;
+            size = readUint(bytes, at + 8, 8);
+            header = 16;
+        }
+        else if (size === 0) {
+            size = end - at;
+        }
+        if (size < header || at + size > end)
+            return null;
+        found.push({
+            type: fourcc(bytes, at + 4),
+            body: at + header,
+            end: at + size,
+        });
+        at += size;
+    }
+    return found;
+}
+// ---------------------------------------------------------------------------
+// WebM: EBML elements, each an ID and a size written as variable-length
+// integers. The header's DocType says webm or matroska; the video track's
+// CodecID is under Segment > Tracks > TrackEntry, where TrackType 1 is video.
+const EBML = 0x1a45dfa3;
+const DOC_TYPE = 0x4282;
+const SEGMENT = 0x18538067;
+const CLUSTER = 0x1f43b675;
+const TRACKS = 0x1654ae6b;
+const TRACK_ENTRY = 0xae;
+const TRACK_TYPE = 0x83;
+const CODEC_ID = 0x86;
+const WEBM_VIDEO = new Set(["V_VP8", "V_VP9"]);
+const WEBM_CODEC_NAMES = {
+    V_AV1: "AV1",
+    "V_MPEG4/ISO/AVC": "H.264 in a Matroska file",
+    "V_MPEGH/ISO/HEVC": "HEVC",
+};
+function webmFormat(bytes) {
+    const top = elements(bytes, 0, bytes.length);
+    const header = top.find((element) => element.id === EBML);
+    const docType = header
+        ? elements(bytes, header.body, header.end).find((element) => element.id === DOC_TYPE)
+        : undefined;
+    const kind = docType ? text(bytes, docType) : "";
+    if (kind !== "webm") {
+        return {
+            refused: kind === "matroska"
+                ? "it is a Matroska file"
+                : "its WebM header is damaged",
+        };
+    }
+    const segment = top.find((element) => element.id === SEGMENT);
+    const tracks = segment
+        ? elements(bytes, segment.body, segment.end).find((element) => element.id === TRACKS)
+        : undefined;
+    if (!tracks)
+        return { refused: "it has no track list" };
+    const codecs = [];
+    for (const entry of elements(bytes, tracks.body, tracks.end)) {
+        if (entry.id !== TRACK_ENTRY)
+            continue;
+        const fields = elements(bytes, entry.body, entry.end);
+        const type = fields.find((field) => field.id === TRACK_TYPE);
+        if (!type || readUint(bytes, type.body, type.end - type.body) !== 1) {
+            continue;
+        }
+        const codec = fields.find((field) => field.id === CODEC_ID);
+        if (codec)
+            codecs.push(text(bytes, codec));
+    }
+    if (codecs.length === 0)
+        return { refused: "it has no video track" };
+    const other = codecs.find((codec) => !WEBM_VIDEO.has(codec));
+    if (other) {
+        return { refused: `its video is ${WEBM_CODEC_NAMES[other] ?? other}` };
+    }
+    return { contentType: "video/webm" };
+}
+/**
+ * The elements between two offsets. An element of unknown size, as a
+ * Segment written while recording is, runs to the end; a Cluster ends the
+ * walk, since the tracks come before the frames.
+ */
+function elements(bytes, start, end) {
+    const found = [];
+    let at = start;
+    while (at < end) {
+        const id = vint(bytes, at, true);
+        if (!id || id.value === null)
+            break;
+        const size = vint(bytes, at + id.length, false);
+        if (!size)
+            break;
+        const body = at + id.length + size.length;
+        if (id.value === CLUSTER)
+            break;
+        const elementEnd = size.value === null ? end : Math.min(end, body + size.value);
+        found.push({ id: id.value, body, end: elementEnd });
+        at = elementEnd;
+    }
+    return found;
+}
+/**
+ * A variable-length integer: the leading zero bits say how many bytes
+ * follow. An ID keeps its length marker; a size drops it, and a size of all
+ * ones is unknown.
+ */
+function vint(bytes, at, keepMarker) {
+    const first = bytes[at];
+    if (first === undefined || first === 0)
+        return null;
+    let length = 1;
+    while (length <= 8 && !(first & (0x80 >> (length - 1))))
+        length++;
+    if (at + length > bytes.length)
+        return null;
+    let value = keepMarker ? first : first & (0xff >> length);
+    let allOnes = value === 0xff >> length;
+    for (let i = 1; i < length; i++) {
+        value = value * 256 + bytes[at + i];
+        if (bytes[at + i] !== 0xff)
+            allOnes = false;
+    }
+    return { value: !keepMarker && allOnes ? null : value, length };
+}
+function text(bytes, element) {
+    return String.fromCharCode(...bytes.subarray(element.body, element.end))
+        .replace(/\0+$/, "")
+        .trim();
+}
+// ---------------------------------------------------------------------------
+function fourcc(bytes, at) {
+    return at + 4 <= bytes.length
+        ? String.fromCharCode(...bytes.subarray(at, at + 4))
+        : "";
+}
+function readUint(bytes, at, length) {
+    let value = 0;
+    for (let i = 0; i < length; i++)
+        value = value * 256 + (bytes[at + i] ?? 0);
+    return value;
+}
+/**
+ * A video and its script, read and checked before anything is uploaded or
+ * recorded (SIGHT-7.0.0, 7.0.1), with its steps' starts (7.4).
+ */
+export function readRecording(path, scriptPath) {
+    const video = readVideo(path);
+    const script = readScript(scriptPath);
+    const stepStarts = readStepStarts(path, script);
+    return { video, script, ...(stepStarts ? { stepStarts } : {}) };
+}
+/**
+ * A recording as it is submitted (SIGHT-7.0, 7.4, 13.2): the app's copy of
+ * the video, by the file's name, with the script's text and its steps'
+ * starts. Nothing goes on the branch.
+ */
+export async function submittedRecording(client, solutionId, { video, script, stepStarts }) {
+    const storageId = await uploadVideo(client, solutionId, video);
+    return {
+        kind: "video",
+        storageId,
+        name: video.name,
+        script,
+        ...(stepStarts ? { stepStarts } : {}),
+    };
+}
+/** Upload a video to the app (SIGHT-7.0), and the stored copy's id back. */
+export function uploadVideo(client, solutionId, video) {
+    return uploadToApp(client, api.solutions.mutations.videoUploadUrl, { solutionId }, video);
+}
+//# sourceMappingURL=video.js.map

package/dist/commands/solution/working-folder.d.ts

@@ -0,0 +1,44 @@
+import type { Reference } from "./things.js";
+/**
+ * A document submitted by its file, as `solutions/mutations:complete` takes
+ * it: on a project with no repository connected the backend saves it on the
+ * solution's branch (BRANCH-1.0); with one, the file is the thing submitted.
+ */
+export type SubmittedFile = {
+    path: string;
+    markdownContent: string;
+    documentId?: string;
+    defaultPrefix?: string;
+};
+/** A document the backend saved on the branch, for its id to go into the file. */
+export type SavedFile = {
+    path: string;
+    documentId: string;
+    version: number;
+};
+/** A document `next` lays out in the working folder (BRANCH-4.0). */
+export type LaidOutFile = {
+    documentId: string;
+    path: string;
+    markdownContent: string;
+    defaultPrefix?: string;
+    version: number;
+    solution?: {
+        solutionId: string;
+        outcome: string;
+    };
+};
+/**
+ * The text of each document among the `file:` things submitted: a Markdown
+ * file that exists, with its frontmatter taken off and what it says about the
+ * document kept beside it. Anything else stays a plain file reference.
+ */
+export declare function readSubmittedFiles(made: Reference[]): SubmittedFile[];
+/**
+ * After a save on the branch, each file carries its document's id, so submitting
+ * the same file again saves that document's next version (BRANCH-4.1).
+ */
+export declare function recordSavedIds(files: SubmittedFile[], saved: SavedFile[]): void;
+/** Write the documents an outcome works from into the working folder (BRANCH-4.0). */
+export declare function layOut(files: LaidOutFile[]): void;
+//# sourceMappingURL=working-folder.d.ts.map

package/dist/commands/solution/working-folder.js

@@ -0,0 +1,64 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parse } from "yaml";
+import { writeRequirementsFile } from "../../schema/file-writer.js";
+import { extractFrontmatterBlock, stripFrontmatterBlock, } from "../../schema/parser-core.js";
+/**
+ * The text of each document among the `file:` things submitted: a Markdown
+ * file that exists, with its frontmatter taken off and what it says about the
+ * document kept beside it. Anything else stays a plain file reference.
+ */
+export function readSubmittedFiles(made) {
+    const files = [];
+    for (const thing of made) {
+        if (thing.kind !== "file" || thing.branch !== undefined)
+            continue;
+        if (!thing.path.endsWith(".md") || !fs.existsSync(thing.path))
+            continue;
+        const content = fs.readFileSync(thing.path, "utf-8");
+        const yaml = extractFrontmatterBlock(content);
+        const frontmatter = (yaml ? parse(yaml) : null);
+        const id = frontmatter?.document?.id;
+        const prefix = frontmatter?.document?.defaultPrefix;
+        files.push({
+            path: thing.path,
+            markdownContent: stripFrontmatterBlock(content),
+            ...(typeof id === "string" && id ? { documentId: id } : {}),
+            ...(typeof prefix === "string" && prefix
+                ? { defaultPrefix: prefix }
+                : {}),
+        });
+    }
+    return files;
+}
+/**
+ * After a save on the branch, each file carries its document's id, so submitting
+ * the same file again saves that document's next version (BRANCH-4.1).
+ */
+export function recordSavedIds(files, saved) {
+    for (const entry of saved) {
+        const file = files.find((f) => f.path === entry.path);
+        if (!file)
+            continue;
+        writeRequirementsFile(entry.path, {
+            documentId: entry.documentId,
+            defaultPrefix: "keep",
+            version: entry.version,
+        }, file.markdownContent);
+    }
+}
+/** Write the documents an outcome works from into the working folder (BRANCH-4.0). */
+export function layOut(files) {
+    for (const file of files) {
+        fs.mkdirSync(path.dirname(file.path), { recursive: true });
+        writeRequirementsFile(file.path, {
+            documentId: file.documentId,
+            defaultPrefix: file.defaultPrefix
+                ? { set: file.defaultPrefix }
+                : "keep",
+            version: file.version,
+            ...(file.solution ? { belonging: file.solution } : {}),
+        }, file.markdownContent);
+    }
+}
+//# sourceMappingURL=working-folder.js.map

package/dist/commands/sync.d.ts

@@ -4,8 +4,9 @@
  * direction (`--cloud-contributes` / `--repo-contributes`) or assign authority
  * (`--repo-wins` / `--cloud-wins`).
  */
+import { type BranchMergeFlags } from "./branch-merge.js";
 import { type SyncAuthOptions } from "./sync-common.js";
-interface SyncOptions extends SyncAuthOptions {
+interface SyncOptions extends SyncAuthOptions, BranchMergeFlags {
     cloudContributes?: boolean;
     repoContributes?: boolean;
     cloudWins?: boolean;

package/dist/commands/sync.js

@@ -8,9 +8,10 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { attachmentSyncNeeded } from "../sync/attachments.js";
 import { executePlan } from "../sync/execute.js";
-import { acquireCloudSnapshot, acquireLocalSnapshot, compareSnapshots, duplicateIdAbortMessage, filterByScope, resolutionHint, } from "../sync/index.js";
+import { acquireCloudSnapshot, acquireLocalSnapshot, compareSnapshots, duplicateIdAbortMessage, filterByScope, projectSolutions, resolutionHint, } from "../sync/index.js";
 import { buildPlan, resolveMode, } from "../sync/plan.js";
 import { brand } from "../utils/brand.js";
+import { branchMergeCommand, branchMergeOf, } from "./branch-merge.js";
 import { resolveCloudAuth } from "./sync-common.js";
 /**
  * The CLI entry point: exits non-zero on unresolved trouble (SYNC-MODE-1.5,
@@ -19,6 +20,12 @@ import { resolveCloudAuth } from "./sync-common.js";
  * the whole command (the report lines still print).
  */
 export async function syncCliAction(scope, options) {
+    // BRANCH-8: a branch merge is a sync of its own, with no local files.
+    const merge = branchMergeOf(scope, options);
+    if (merge) {
+        await branchMergeCommand(merge);
+        return;
+    }
     const result = await syncCommand(scope, options);
     if (result === "trouble") {
         process.exitCode = 1;
@@ -38,9 +45,14 @@ export async function syncCommand(scope, options) {
         mode = resolveMode(options);
     }
     const auth = resolveCloudAuth(options);
-    const [local, cloud] = await Promise.all([
-        acquireLocalSnapshot(workspaceRoot),
-        acquireCloudSnapshot(auth),
+    // SOLACCESS-2.2: whether the project's team has solutions decides which
+    // files the sync carries.
+    const cloud = await acquireCloudSnapshot(auth);
+    const [local, solutions] = await Promise.all([
+        acquireLocalSnapshot(workspaceRoot, undefined, {
+            solutions: cloud.solutions === true,
+        }),
+        projectSolutions(auth, cloud),
     ]);
     // SYNC-MODE-4.4 (and 4.4.0 for --yes): an empty repo is indistinguishable from a wrong working
     // directory or a failed checkout — never treat it as intent to delete every
@@ -122,7 +134,7 @@ export async function syncCommand(scope, options) {
         return "clean";
     }
     console.log(`\nSyncing with ${brand} cloud...`);
-    const outcome = await executePlan(plan, cloud, auth, workspaceRoot, mode);
+    const outcome = await executePlan(plan, cloud, auth, workspaceRoot, mode, solutions);
     // Report.
     if (outcome.cloudCreated)
         console.log(`  Created in cloud: ${outcome.cloudCreated}`);
@@ -179,6 +191,10 @@ export async function syncCommand(scope, options) {
     for (const { name, warning } of outcome.publishWarnings) {
         console.log(`  ⚠ ${name}: ${warning}`);
     }
+    // SOLDOC-5: a file's path and frontmatter disagree about where it belongs.
+    for (const warning of outcome.belongingWarnings ?? []) {
+        console.log(`  ⚠ ${warning}`);
+    }
     // SYNC-CLI-EDIT-3.1: the cloud stores the web editor's notation, and files
     // written another way converge to it on push. Each file NAMED, not counted —
     // a count leaves Jaime to find out which files changed from `git diff`,

package/dist/convex.d.ts

@@ -20,6 +20,7 @@ export declare const api: {
             exportDocument: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
             exportProject: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
             exportProjectForShare: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            foreignDocumentIds: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
             deleteForSync: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
@@ -68,6 +69,59 @@ export declare const api: {
             ensureProjectShareToken: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
+    scores: {
+        mutations: {
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            update: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+    };
+    mockups: {
+        mutations: {
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+    };
+    solutions: {
+        queries: {
+            getPlan: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getThread: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getThings: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            defaultPlan: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            readPlanFile: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getOutcomePage: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getAgentLogs: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            forSync: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            rehearsalsOf: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            rehearsalHistory: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+        };
+        mutations: {
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            start: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            next: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            complete: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            ask: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            stall: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            answer: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            approveCheckpoint: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            removeRehearsal: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            videoUploadUrl: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+        shares: {
+            forCheckout: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            push: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            done: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+        images: {
+            uploadUrl: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            inputUploadUrl: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            copies: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+        };
+        branches: {
+            branchOf: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            claim: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            recordPush: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            removal: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+        };
+    };
     lib: {
         authActions: {
             exchangeAuthorizationCode: import("convex/server").FunctionReference<"action", "public", any, any, string | undefined>;