@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/conversations/turns.d.ts

@@ -0,0 +1,134 @@
+import type { AgentConnection } from "../agents";
+import type { ConversationFiles } from "./files";
+import type { ConversationDeps, ConversationHost } from "./host";
+import type { Attached, Checkpoint, Device, Taking, Upload } from "./state";
+/** What else a prompt says about who said it. */
+/** What a checkpoint is asked for, past a restart's. */
+export interface CheckpointCause {
+    /** The person's pause, which nothing resumes. */
+    pause?: boolean;
+    /** Why a worker budget hard stop asks it, for the budget to resume. */
+    budget?: string | null;
+}
+export interface PromptOptions {
+    /** The conversation that said it with `splates tell`, when the person did not. */
+    told?: string;
+    /** Whether the person said it into the mic rather than typed it. */
+    dictated?: boolean;
+    /** The id the page gave it, so the page knows its own copy when it comes back. */
+    id?: string;
+    /**
+     * Whether it stops the running turn and follows it, rather than joining
+     * it, for a change of plans.
+     */
+    stop?: boolean;
+}
+/**
+ * The turns of a conversation: what the person says goes to the agent as a
+ * prompt, steered into the turn it is running or queued for when that ends,
+ * and a checkpoint asks it to stop where it is.
+ */
+export declare class ConversationTurns {
+    private readonly host;
+    private readonly deps;
+    private readonly connection;
+    private readonly files;
+    /** Whether the person cancelled the last turn, which holds the queue. */
+    private held;
+    /** Gives up on an asked checkpoint once `CHECKPOINT_WAIT` is out. */
+    private waiting;
+    /** Whether a checkpoint is cancelling the turn, whose end is not its own. */
+    private interrupting;
+    constructor(host: ConversationHost, deps: ConversationDeps, connection: AgentConnection, files: ConversationFiles);
+    /**
+     * Says `text` to the agent, with `files`, once it has started, resuming
+     * the session first when it stopped and unarchiving it when archived.
+     * While the agent works, it joins the
+     * running turn when the agent can take it there, and otherwise waits for
+     * the turn to end.
+     */
+    prompt(text: string, files?: Upload[], from?: Device, { told, dictated, stop, id }?: PromptOptions): Promise<void>;
+    /**
+     * Records the message as queued and flushes it, then waits for the session
+     * to open (`opening`, or what starts it) and sends it first once the agent
+     * is idle. A start that fails takes the message back out, so the refusal
+     * the person sees is the whole story.
+     */
+    private queueUntilOpen;
+    /**
+     * What `prompt` would do with a message said now, which the page shows it
+     * as: it follows the same rules as `prompt` does.
+     */
+    taking(): Taking;
+    /**
+     * Back to idle once a turn ends, then on to what was queued meanwhile,
+     * unless the person cancelled the turn: that holds the queue until they
+     * say something.
+     */
+    ended(error: string | null): void;
+    /**
+     * Marks a running turn as cut short, as when the connection is lost or the
+     * process exits, unless the person stopped it, which says so already.
+     * Answers whether it did.
+     */
+    interrupt(): boolean;
+    /** Whether a checkpoint has ended and nothing has been said since. */
+    get stoppedByCheckpoint(): boolean;
+    /**
+     * Asks the agent to bring its `SPLATES.md` up to date and stop, as before
+     * a restart. Pass `merging` when its turn is landing a task, and say why
+     * it stops: a `budget` stop resumes once the worker budget allows again,
+     * a `pause` never does. What the person queued stays queued.
+     */
+    checkpoint(merging: boolean, { pause, budget }?: CheckpointCause): Promise<void>;
+    /**
+     * Forgets the checkpoint, done or not, so the next starts afresh; an agent
+     * still on it carries on with its turn.
+     */
+    dismissCheckpoint(): void;
+    /**
+     * Keeps where the checkpoint stands, giving up the wait once it is past
+     * asked; a pause past asked is forgotten.
+     */
+    mark(checkpoint: Checkpoint | null): void;
+    /** Settles once the checkpoint asked is no longer under way. */
+    answered(): Promise<void>;
+    /**
+     * Takes back the `index`th queued message before the agent hears it,
+     * answering with its words and files, for the person to edit and send
+     * again.
+     */
+    unqueue(index: number): {
+        text: string;
+        files: Attached[];
+    };
+    /**
+     * Sends what is queued now: stops the running turn, whose end sends it,
+     * or, with no turn running, sends it as one.
+     */
+    sendNow(): Promise<void>;
+    /**
+     * Starts the agent again for what was said while a start the server cut
+     * short was under way, saying the first of it once the session opens, as
+     * that start would have, and the rest once its turn ends.
+     */
+    sayUnsaid(): Promise<void>;
+    /**
+     * Stops the agent's turn for the person, marking the turn as one they
+     * stopped, and leaves the conversation open for the next.
+     */
+    cancel(): Promise<void>;
+    /** Holds `words` and `sent` for when the turn ends, shown as said. */
+    private queue;
+    /**
+     * Starts a turn on `fresh`, with every message still queued ahead of it,
+     * as one prompt, or on `fresh` alone, leaving the queue as it is.
+     */
+    private send;
+    /** What `messages` say, as one prompt, for the tree the agent runs in. */
+    private content;
+    /** Settles once no turn is running, or the checkpoint has given up. */
+    private idle;
+    /** Stops the agent's turn, holding what is queued for the next prompt. */
+    private halt;
+}

package/vendor/@stringsync/splates-server/conversations/updates.d.ts

@@ -0,0 +1,21 @@
+import type { ConversationState, Message } from "./state";
+/** A conversation's changed fields and message slots, relative to its last streamed copy. */
+export interface ConversationDelta {
+    id: string;
+    changes: Partial<Omit<ConversationState, "id" | "messages">>;
+    removed: (keyof ConversationState)[];
+    messages?: {
+        length: number;
+        replace: [number, Message][];
+    };
+}
+/** Tracks a connection’s conversations; call `next` for each state to send. */
+export declare class ConversationUpdates {
+    private readonly held;
+    /** Starts a new baseline, or returns only what moved since the previous copy. */
+    next(state: ConversationState): ConversationState | ConversationDelta;
+    /** Forgets a deleted conversation so a reused id starts with a full copy. */
+    drop(id: string): void;
+    /** Applies a delta without replacing unchanged messages or their array. */
+    static apply(before: ConversationState, delta: ConversationDelta): ConversationState;
+}

package/vendor/@stringsync/splates-server/creds/creds.d.ts

@@ -0,0 +1,86 @@
+import { Credentials, type SecretStore } from "../../../core/creds/index.js";
+import { Duration } from "../../../core/time/index.js";
+import type { Storage } from "../storage";
+import { type CredRequest, type KeptCred } from "./requests";
+import { type Provider, type Scope, type SecretStores } from "./stores";
+/** How long `wait` gives a request before handing the wait back to its caller. */
+export declare const DEFAULT_TIMEOUT: Duration;
+/**
+ * A project's creds: the requests agents make for them, which `splates server`
+ * shows on its Creds page for a person to fill, and the two stores they are
+ * kept in, the project's and the device's, as `wiz creds` keeps them. A value
+ * goes into a store and never comes out through here but to code reading it
+ * through `credentials`, so no agent, page or log ever holds it.
+ */
+export declare class Creds {
+    #private;
+    private readonly stores;
+    constructor(
+    /** The project's, holding `creds.json`. */
+    storage: Storage, stores: Record<Scope, SecretStore>);
+    /** The project's creds, kept in `stores`. */
+    static open(storage: Storage, root: string, stores: SecretStores): Promise<Creds>;
+    /**
+     * Where code reads a cred's value: the project's store, then the device's. Never the
+     * environment, so a stray export is not what splates reads.
+     */
+    get credentials(): Credentials;
+    /** Who can keep a cred here, the system's first. */
+    get providers(): Provider[];
+    /** Every request, open or not, the latest first. */
+    requests(): Promise<CredRequest[]>;
+    /**
+     * Asks a person for `name`, saying what for, kept in `scope`'s store once they save it.
+     * Asks nothing, returning null, when that store already keeps it, unless
+     * `replace` says the value kept there does not work, and then a purpose or
+     * instructions left off are those of the last request for `name`.
+     */
+    request(name: string, { scope, provider, purpose, instructions, task, replace, }: {
+        scope: Scope;
+        provider?: Provider;
+        purpose: string;
+        instructions: string;
+        task: string | null;
+        replace?: boolean;
+    }): Promise<CredRequest | null>;
+    /**
+     * Blocks until a person fills or dismisses the request for `name`,
+     * returning what became of it; gives up with `timeout`.
+     */
+    wait(name: string, { timeout, poll, }?: {
+        timeout?: Duration;
+        poll?: Duration;
+    }): Promise<"saved" | "dismissed">;
+    /**
+     * Keeps `value` as `name`, filling its request if one is open, in the
+     * request's scope, in `provider` if given, else the request's, and else
+     * `scope` and the system's. `by` names the tool saving it, for
+     * the page to say; a person's own save says nothing.
+     */
+    save(name: string, value: string, { scope, provider, by, }?: {
+        scope?: Scope;
+        provider?: Provider;
+        by?: string | null;
+    }): Promise<Scope>;
+    /** Turns down the open request for `name`, so its agent stops waiting. */
+    dismiss(name: string): Promise<void>;
+    /** Deletes `name` from `provider`'s `scope` store; whether there was one. */
+    remove(name: string, scope: Scope, provider?: Provider): Promise<boolean>;
+    /**
+     * Copies each cred kept under arbor's `ARBOR_*` name to its `SPLATES_*`
+     * one in the same store, unless that is kept already. The old one stays,
+     * for an arbor still running, and any record naming it, to read.
+     */
+    copyLegacy(): Promise<void>;
+    /**
+     * Every cred the stores keep, each provider's project store first, by name.
+     * Parameter Store out of reach lists nothing rather than hide the rest.
+     */
+    kept(): Promise<KeptCred[]>;
+    /** What a person calls a store, as in "the macOS Keychain". */
+    label(scope: Scope, provider?: Provider): string;
+    private store;
+    private has;
+    private read;
+    private change;
+}

package/vendor/@stringsync/splates-server/creds/index.d.ts

@@ -0,0 +1,6 @@
+export { Creds, DEFAULT_TIMEOUT } from "./creds";
+export { KeyFileStore } from "./key-file";
+export type { CredRequest, KeptCred } from "./requests";
+export { CredRoutes } from "./routes";
+export type { Provider, Scope, SecretStores } from "./stores";
+export { cannotReach, PROVIDERS, SCOPES, SYSTEM_STORES, systemStores, } from "./stores";

package/vendor/@stringsync/splates-server/creds/index.js

@@ -0,0 +1,28 @@
+import {
+  KeyFileStore2,
+  SCOPES2,
+  PROVIDERS2,
+  systemStores2,
+  cannotReach2,
+  SYSTEM_STORES2,
+  DEFAULT_TIMEOUT2,
+  Creds2,
+  CredRoutes2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  CredRoutes2 as CredRoutes,
+  Creds2 as Creds,
+  DEFAULT_TIMEOUT2 as DEFAULT_TIMEOUT,
+  KeyFileStore2 as KeyFileStore,
+  PROVIDERS2 as PROVIDERS,
+  SCOPES2 as SCOPES,
+  SYSTEM_STORES2 as SYSTEM_STORES,
+  cannotReach2 as cannotReach,
+  systemStores2 as systemStores
+};

package/vendor/@stringsync/splates-server/creds/key-file.d.ts

@@ -0,0 +1,21 @@
+import type { SecretStore } from "../../../core/creds/index.js";
+import type { Fs } from "../../../core/system/index.js";
+/**
+ * Secrets kept in a file only its user may read (`0600`), as `NAME=value`
+ * lines, for a machine whose system store is locked or missing when it
+ * boots, as WSL's is with no one signed in or a headless Linux's with no
+ * secret service: a worker's key and Access token with `--key-file`, a
+ * server's creds with `SPLATES_SECRET_STORE=file`.
+ */
+export declare class KeyFileStore implements SecretStore {
+    readonly path: string;
+    private readonly fs;
+    readonly label: string;
+    constructor(path: string, fs: Fs);
+    get(name: string): Promise<string | undefined>;
+    set(name: string, value: string): Promise<void>;
+    delete(name: string): Promise<boolean>;
+    names(): Promise<string[]>;
+    private read;
+    private write;
+}

package/vendor/@stringsync/splates-server/creds/requests.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { type Provider, type Scope } from "./stores";
+export declare const REQUEST: z.ZodObject<{
+    name: z.ZodString;
+    scope: z.ZodEnum<{
+        device: "device";
+        project: "project";
+    }>;
+    provider: z.ZodDefault<z.ZodEnum<{
+        system: "system";
+    }>>;
+    purpose: z.ZodDefault<z.ZodString>;
+    instructions: z.ZodString;
+    task: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        dismissed: "dismissed";
+        open: "open";
+        saved: "saved";
+    }>;
+    requestedAt: z.ZodString;
+}, z.core.$strip>;
+/** A cred an agent asked a person for, with what for and how to get it. */
+export type CredRequest = z.infer<typeof REQUEST>;
+export declare const FILE: z.ZodObject<{
+    requests: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        scope: z.ZodEnum<{
+            device: "device";
+            project: "project";
+        }>;
+        provider: z.ZodDefault<z.ZodEnum<{
+            system: "system";
+        }>>;
+        purpose: z.ZodDefault<z.ZodString>;
+        instructions: z.ZodString;
+        task: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            dismissed: "dismissed";
+            open: "open";
+            saved: "saved";
+        }>;
+        requestedAt: z.ZodString;
+    }, z.core.$strip>>>;
+    savedBy: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type CredsFile = z.infer<typeof FILE>;
+/** A cred a store keeps, by name; never its value. */
+export interface KeptCred {
+    name: string;
+    scope: Scope;
+    provider: Provider;
+    /** The tool that saved it, when one said so; null when a person did. */
+    savedBy: string | null;
+}

package/vendor/@stringsync/splates-server/creds/routes.d.ts

@@ -0,0 +1,16 @@
+import type { Project, ProjectWatch } from "../server/shared";
+/**
+ * How a project's Creds page fills, replaces and removes creds, and turns
+ * requests down. A value only ever comes in: no route answers with one.
+ * Each handler is a property, so `serveProject` spreads them into the
+ * project's routes.
+ */
+export declare class CredRoutes {
+    #private;
+    constructor(project: Project, watch: ProjectWatch);
+    /** What each store keeps, by name, and what the stores are called. */
+    readonly listCreds: () => Promise<Response>;
+    readonly saveCred: (request: Request) => Promise<Response>;
+    readonly removeCred: (request: Request) => Promise<Response>;
+    readonly dismissCred: (request: Request) => Promise<Response>;
+}

package/vendor/@stringsync/splates-server/creds/stores.d.ts

@@ -0,0 +1,37 @@
+import { type SecretStore } from "../../../core/creds/index.js";
+import { type Fs } from "../../../core/system/index.js";
+/** Where a cred is kept: for this project alone, or every project on this device. */
+export declare const SCOPES: readonly ["project", "device"];
+export type Scope = (typeof SCOPES)[number];
+/** Who keeps a cred: the machine's own store. */
+export declare const PROVIDERS: readonly ["system"];
+export type Provider = (typeof PROVIDERS)[number];
+/**
+ * The operating system's own stores, shared with `wiz creds`.
+ * `SPLATES_SECRET_STORE=keyring` or `file` settles which; unset, the keyring.
+ * `file` keeps them in files only this user may read under
+ * `~/.splates/secrets/`, for a Linux with no secret service.
+ */
+export declare function systemStores(opts?: SystemStoresOptions): SecretStores;
+/**
+ * Why `store` refused, and what a Linux with no secret service can do: run
+ * one, or keep its secrets in files.
+ */
+export declare function cannotReach(store: SecretStore, error: unknown): string;
+/** The two stores of one provider. */
+export interface StoreSet {
+    /** The store of the project whose main tree is at `root`. */
+    project(root: string): Promise<SecretStore>;
+    device: SecretStore;
+}
+/** The stores a cred can be kept in, the system's unless a test says otherwise. */
+export type SecretStores = StoreSet;
+export interface SystemStoresOptions {
+    platform?: string;
+    /** `SPLATES_SECRET_STORE`: `keyring` or `file` to choose; unset to detect. */
+    choice?: string;
+    /** Where `file` keeps its files, splates's home unless a test says otherwise. */
+    home?: string;
+    fs?: Fs;
+}
+export declare const SYSTEM_STORES: SecretStores;

package/vendor/@stringsync/splates-server/dictate/connection.d.ts

@@ -0,0 +1,18 @@
+import { type Transcriber } from "../../../core/dictate/index.js";
+import type { Connection } from "../server/shared";
+/**
+ * One dictation's socket, relaying the page's audio to a transcription and
+ * its text back. A socket that closes takes its transcription with it: the
+ * text heard so far is already in the composer.
+ */
+export declare class DictationConnection implements Connection {
+    /** Null when the project has no key, which the Creds page now asks for. */
+    private readonly transcriber;
+    private relay;
+    constructor(
+    /** Null when the project has no key, which the Creds page now asks for. */
+    transcriber: Promise<Transcriber | null>);
+    open(socket: Bun.ServerWebSocket<Connection>): void;
+    message(_socket: Bun.ServerWebSocket<Connection>, message: string | Buffer<ArrayBuffer>): void;
+    closed(): void;
+}

package/vendor/@stringsync/splates-server/dictate/dictate.d.ts

@@ -0,0 +1,16 @@
+import type { Connection, Served } from "../server/shared";
+import { type HostGate } from "../server/shared";
+/** How a dictation finds the project its request names. */
+export interface DictationProjects {
+    projectFor(request: Request): Promise<Served>;
+}
+/**
+ * The composer's dictations, each over a WebSocket: the page streams the
+ * mic's audio up, and the text comes back as it is heard.
+ */
+export declare class Dictations {
+    private readonly gate;
+    private readonly projects;
+    constructor(gate: HostGate, projects: DictationProjects);
+    readonly open: (request: Request, server: Bun.Server<Connection>) => Promise<Response | undefined>;
+}

package/vendor/@stringsync/splates-server/dictate/index.d.ts

@@ -0,0 +1,4 @@
+export { Dictations } from "./dictate";
+export { PersonalWords, parseWords, personalWordsPath } from "./personal";
+export type { TranscriberFor } from "./transcriber";
+export { OPENAI_KEY, transcriberFor } from "./transcriber";

package/vendor/@stringsync/splates-server/dictate/personal.d.ts

@@ -0,0 +1,26 @@
+import type { Fs } from "../../../core/system/index.js";
+/**
+ * The words a person dictates in every project, kept in one file under
+ * their home rather than in any project's config, which is checked in.
+ */
+export declare class PersonalWords {
+    /** `~/.splates/dictation.json`, or a test's own. */
+    readonly path: string;
+    private readonly deps;
+    constructor(
+    /** `~/.splates/dictation.json`, or a test's own. */
+    path: string, deps: {
+        fs: Fs;
+    });
+    /** Whether the person has saved a list, even an empty one. */
+    saved(): Promise<boolean>;
+    /** The words as the file keeps them; none when there is no file. */
+    words(): Promise<string[]>;
+    save(words: readonly string[]): Promise<void>;
+    /** Deletes the file; none there is fine. */
+    remove(): Promise<void>;
+}
+/** Where this machine keeps the person's words, under `home`, `~/.splates`. */
+export declare function personalWordsPath(home: string): string;
+/** The words in a list typed as commas or lines, trimmed, empty ones dropped. */
+export declare function parseWords(text: string): string[];

package/vendor/@stringsync/splates-server/dictate/transcriber.d.ts

@@ -0,0 +1,16 @@
+import type { Transcriber } from "../../../core/dictate/index.js";
+import type { Project } from "../server/shared";
+/** The cred a dictation transcribes with. */
+export declare const OPENAI_KEY = "OPENAI_API_KEY";
+/** What a dictation in a project transcribes with, null once it asked for a key. */
+export type TranscriberFor = (project: Project, 
+/** Tells the project's pages that its records moved, as a new request does. */
+tick: () => void) => Promise<Transcriber | null>;
+/**
+ * What a dictation in `project` transcribes with: OpenAI on the key the
+ * project's or the device's store keeps, told splates's, the project's and
+ * the person's words (`dictationWords`, `~/.splates/dictation.json`) so it
+ * spells them its way, read afresh for each take. Null, after asking for the
+ * key on the Creds page, when neither store keeps one.
+ */
+export declare const transcriberFor: TranscriberFor;

package/vendor/@stringsync/splates-server/dictate/vocabulary.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The most words a take is told: the model's prompt is short, and a list
+ * cut off part way helps less than a shorter one.
+ */
+export declare const MAX_WORDS = 50;
+/**
+ * Project words a speech model should spell as written: splates and the
+ * project always, then the project's config's, then the person's, each once.
+ */
+export declare function words(project: string, ...lists: readonly (readonly string[])[]): string[];
+/** The prompt that gets `listed` words spelled their way. */
+export declare function vocabulary(listed: readonly string[]): string;

package/vendor/@stringsync/splates-server/evals/agents-routes.d.ts

@@ -0,0 +1,27 @@
+import type { Fs } from "../../../core/system/index.js";
+import { type AutoPickAgent } from "../auto-pick";
+import type { AgentPick } from "../models";
+import { type Handler } from "../server/shared";
+/** The agents the Evals page edits, with what each pick can name. */
+export interface EvalAgentsView {
+    /** The agents saved; none when the file is missing or broken. */
+    agents: AgentPick[];
+    /** Why the file could not be read, so saving would replace it; null when it read. */
+    problem: string | null;
+    /** The roster's agents the runner can start natively, for a pick to name. */
+    roster: AutoPickAgent[];
+}
+/** How the Evals page reads and writes this machine's eval agents. */
+export declare class EvalAgentsRoutes {
+    private readonly opts;
+    private readonly store;
+    constructor(opts: {
+        fs: Fs;
+        home: string;
+    });
+    /** The agents and what a pick can name. */
+    readonly read: Handler;
+    /** Saves the body's `agents`, answering the view of them, or a 400 saying what does not check out. */
+    readonly save: Handler;
+    private view;
+}

package/vendor/@stringsync/splates-server/evals/agents.d.ts

@@ -0,0 +1,25 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { AgentPick } from "../models";
+/** The agents an eval runs on, as the file keeps them. */
+export interface EvalAgents {
+    /** The file's own format. */
+    format: 1;
+    /** Each a full pick; one agent and model may stand at several thinking levels. */
+    agents: AgentPick[];
+}
+/** The agents the eval runner starts natively, by roster id. */
+export declare const NATIVE_AGENTS: string[];
+/** The eval agents as `~/.splates/eval-agents.json` keeps them, one list for every project on the machine. */
+export declare class EvalAgentsStore {
+    /** The file's path, or a test's own. */
+    readonly path: string;
+    private readonly fs;
+    constructor(
+    /** The file's path, or a test's own. */
+    path: string, fs: Fs);
+    /** The agents saved; none when there is no file. */
+    agents(): Promise<AgentPick[]>;
+    /** Writes `agents` once they check out, refusing them, file untouched, when not. */
+    save(agents: unknown): Promise<void>;
+    private checked;
+}

package/vendor/@stringsync/splates-server/evals/contract.d.ts

@@ -0,0 +1,73 @@
+import type { EvalCell, EvalCheck, EvalDetail, EvalStep, EvalTarget, EvalVerdict } from "./types";
+/** What a `batch.json` in the public format says it is. */
+export declare const CONTRACT_FORMAT = "splates-evals/1";
+/** The file each finished cell appends its line to, in its batch's directory. */
+export declare const RESULTS_FILE = "results.jsonl";
+/** Whether `saved`, a `batch.json`, is in the public format. */
+export declare function isContractBatch(saved: unknown): saved is ContractBatch;
+/** The run id of cell `cell` of batch `batch`, as `EvalRun.id` names it. */
+export declare function contractRunId(batch: string, cell: string): string;
+/** The cells of `batch`, saved in directory `dir` as `id`, each with its last result line. */
+export declare function contractCells(dir: string, id: string, batch: ContractBatch): Promise<{
+    targets: EvalTarget[];
+    grid: EvalCell[];
+}>;
+/** Cell `cell` of the batch in `dir`, saved as `id`, opened whole; null when it has not finished. */
+export declare function contractDetail(dir: string, id: string, batch: ContractBatch, cell: string): Promise<EvalDetail | null>;
+/**
+ * `batch.json` as any framework writes it (`designs/evals-contract.md`):
+ * every cell it plans, before any runs.
+ */
+export interface ContractBatch {
+    format: typeof CONTRACT_FORMAT;
+    /** As ISO 8601. */
+    startedAt: string;
+    title?: string;
+    /** Who wrote the batch; `splates` for splates's own harness, which the page gives its skill controls. */
+    producer?: string;
+    cells: ContractCell[];
+}
+/** One case on one target at one repetition. */
+export interface ContractCell {
+    /** Unique in its batch; what a result line names it by. */
+    id: string;
+    case: string;
+    /** What the page groups cases under. */
+    group?: string;
+    /** What the case asks, in words. */
+    about?: string;
+    target: ContractTarget;
+    repetition?: number;
+}
+/** Free-form labels for what a cell ran on. */
+export interface ContractTarget {
+    model: string;
+    agent?: string;
+    effort?: string;
+    /** Anything else the run varied, such as a prompt's revision. */
+    variant?: string;
+}
+/** A line of `results.jsonl`: how one cell ended. */
+export interface ContractResult {
+    cell: string;
+    status: "pass" | "fail" | "error";
+    /** From 0 to 1, for a framework that grades on a scale. */
+    score?: number;
+    reason?: string;
+    tokens?: number;
+    costUsd?: number;
+    milliseconds?: number;
+    /** The framework's own view of the cell. */
+    url?: string;
+    /** A JSON file in the batch's directory with what the cell did, `ContractDetail`. */
+    detail?: string;
+}
+/** What a result's `detail` file holds, every field optional. */
+export interface ContractDetail {
+    input?: string;
+    rubric?: string;
+    reply?: string;
+    checks?: EvalCheck[];
+    judge?: EvalVerdict;
+    transcript?: EvalStep[];
+}

package/vendor/@stringsync/splates-server/evals/done.d.ts

@@ -0,0 +1,11 @@
+import type { EvalDetail, EvalGrid } from "./types";
+/**
+ * What tells the agent whose run evals card started `grid` that it is done:
+ * the directive, then the batch condensed: its tally and cost, each scenario's
+ * outcome on each agent (a pass rate over repetitions), and for each run that
+ * failed, the checks and the judge's reason that held it back, its reply cut
+ * short and how to show it in full; then the runs that errored, apart, since
+ * an error is never the skill's. `details` are the runs that did not pass,
+ * opened.
+ */
+export declare function evalsDonePrompt(grid: EvalGrid, details: readonly EvalDetail[]): string;