@stringsync/splates 0.0.0-stage → 0.0.45

package/dev/api.d.ts

@@ -0,0 +1,209 @@
+/**
+ * The page's writes: the same core functions as `splates todo add`, `update`
+ * and `remove`, and the lanes' own.
+ * A refusal comes back as the CLI's own reason and message, thrown so the
+ * caller can show it.
+ */
+import type { HeavyJobsReading } from "webappwiz/system";
+import type { KeptCred, Scope } from "../creds.js";
+import type { PortLink } from "../dev-task-ports.js";
+import type { FileDiff } from "../diff.js";
+import type { Landed } from "../landed.js";
+import type { MachineReading } from "../machine.js";
+import type { Wants } from "../notices.js";
+import type { AgentPick } from "../roster.js";
+import type { SetupProgress } from "../setup.js";
+import type { PeriodId, Stats } from "../stats.js";
+import type { SystemsReport } from "../system-changes.js";
+import type { NamedSystem } from "../systems.js";
+export declare class ApiError extends Error {
+    readonly reason: string;
+    constructor(reason: string, message: string);
+}
+/**
+ * `path` for the project this page shows: the one `?project=` names, or none
+ * for the one `splates server` started in, unless `path` names one itself. Every
+ * request the page makes goes through here.
+ */
+export declare function scoped(path: string): string;
+/**
+ * POSTs to `path` for this project, or as `init` says, answering with the
+ * body, or throwing the refusal as an `ApiError`.
+ */
+export declare function send(path: string, init: RequestInit): Promise<unknown>;
+/** A todo's files: new ones to add, and the stored ones to keep. */
+export interface FilesForm {
+    files: File[];
+    /** Paths of files already stored to keep; the rest are dropped. */
+    keep: string[];
+}
+/** What a todo says: a line, and whatever more there is to say. */
+export interface TodoForm {
+    subject: string;
+    text: string;
+    /** Where it goes in the list, 1 at the top; absent leaves it be. */
+    position?: number;
+}
+/** Adds a todo at the bottom of `lane`, or of the untriaged ones for null. */
+export declare function addTodo({ subject, text, position }: TodoForm, files: File[], lane?: number | null): Promise<void>;
+export declare function updateTodo(id: number, { subject, text, position, files, keep }: FilesForm & TodoForm): Promise<void>;
+/** Puts a todo at `position`, 1 at the top, moving the rest around it. */
+export declare function moveTodo(id: number, position: number): Promise<void>;
+/** `send` with `body` as JSON, by `method`. */
+export declare function sendJson(path: string, method: string, body: unknown): Promise<unknown>;
+/** Says `id` is blocked by exactly the todos in `blockedBy`, no more and no fewer. */
+export declare function linkTodo(id: number, blockedBy: number[]): Promise<void>;
+/**
+ * Puts a todo in `lane` (`"new"` for one of its own, null for none), just
+ * above the todo `before`, or at the bottom of the lane without one.
+ */
+export declare function arrangeTodo(id: number, lane: number | "new" | null, before?: number, 
+/** What to call a new lane; named after the todo without one. */
+name?: string): Promise<void>;
+/** Has `assignee` work todo `id`, or nobody in particular for null. */
+export declare function assignTodo(id: number, assignee: AgentPick | null): Promise<void>;
+/** Moves lane `from`'s todos to the bottom of lane `into`. */
+export declare function joinLanes(from: number, into: number): Promise<void>;
+/** Starts an empty lane called `name`, after the others. */
+export declare function addLane(name: string): Promise<void>;
+/** Calls lane `id` by another name. */
+export declare function renameLane(id: number, name: string): Promise<void>;
+/** Puts lane `id` at `position` among the lanes, 1 the first column. */
+export declare function moveLane(id: number, position: number): Promise<void>;
+/** Removes lane `id`, putting its todos back with the untriaged ones. */
+export declare function dropLane(id: number): Promise<void>;
+/** Removes a todo, kept for `restoreTodo` to put back. */
+export declare function removeTodo(id: number): Promise<void>;
+/** Puts back a todo `removeTodo` removed, under its id, where it stood. */
+export declare function restoreTodo(id: number): Promise<void>;
+/** Where the page loads a file a todo holds. */
+export declare function fileUrl(path: string): string;
+/**
+ * The files and directories (ending in `/`) a task's tree holds, or the main
+ * tree's for none: what `@` offers.
+ */
+export declare function paths(task?: string): Promise<string[]>;
+/** Every system `task`'s worktree names, or the main tree's for none. */
+export declare function systems(task?: string): Promise<NamedSystem[]>;
+/** What each system holds on trunk, and the commits that lately changed it. */
+export declare function systemChanges(): Promise<SystemsReport>;
+/** What `task` changed against its base, uncommitted edits included. */
+export declare function taskDiff(task: string): Promise<FileDiff[]>;
+/**
+ * How `task` went once it merged, beside its project's week before; null
+ * when it never merged here.
+ */
+export declare function taskOutcome(task: string): Promise<Landed | null>;
+/**
+ * Gives `task`, escalated once it spent its merge attempts, another round of
+ * them, as `splates retry` does.
+ */
+export declare function retryTask(task: string): Promise<void>;
+/**
+ * `splates remove` for `task`, past any lease, stopping each conversation in
+ * its tree and moving it to the main tree.
+ */
+export declare function removeTask(task: string): Promise<void>;
+/**
+ * How tasks ended across every project, summed for the Stats page over
+ * `period`.
+ */
+export declare function stats(period: PeriodId): Promise<Stats>;
+/**
+ * The email Cloudflare Access signed this page's visitor in with, or null
+ * when the page is opened on this machine or Access is off.
+ */
+export declare function identity(): Promise<string | null>;
+/**
+ * Each port a task serves now, with its link through the ports host, if one
+ * is saved, and on the machine `splates server` runs on.
+ */
+export declare function taskPorts(): Promise<PortLink[]>;
+/** What the page shows of the machine: its reading, and its heavy jobs. */
+export type MachineStatus = MachineReading & {
+    heavy: HeavyJobsReading;
+};
+/** How hard the machine `splates server` runs on is working right now. */
+export declare function machine(): Promise<MachineStatus>;
+/** This machine's setup: every step checked, by area, and the one to do next. */
+export declare function setup(): Promise<SetupProgress>;
+/** Skips setup step `step`, or asks for it again, answering the fresh progress. */
+export declare function skipSetupStep(step: string, skipped: boolean): Promise<SetupProgress>;
+/** Marks setup seen on this machine, so the page stops nudging towards it. */
+export declare function seeSetup(): Promise<SetupProgress>;
+/** The public key this device subscribes to the server's pushes with. */
+export declare function pushKey(): Promise<string>;
+/** Has the server push this device the notices `wants` asks for, at `subscription`. */
+export declare function subscribePush(subscription: PushSubscriptionJSON, wants: Wants & {
+    inFront: boolean;
+}): Promise<void>;
+/** Has the server stop pushing to the subscription `endpoint` names. */
+export declare function unsubscribePush(endpoint: string): Promise<void>;
+/** What the project's store and the device's keep, by name, and what each store is called. */
+export interface KeptCreds {
+    kept: KeptCred[];
+    labels: Record<Scope, string>;
+}
+/** The creds kept for this project and this device; never a value. */
+export declare function keptCreds(): Promise<KeptCreds>;
+/**
+ * Keeps `value` as `name`: in the scope its open request asked for, else in
+ * `scope`. The value goes to the store and never comes back.
+ */
+export declare function saveCred(name: string, value: string, scope?: Scope): Promise<void>;
+export declare function removeCred(name: string, scope: Scope): Promise<void>;
+/** Turns down the open request for `name`, so the agent waiting on it stops. */
+export declare function dismissCred(name: string): Promise<void>;
+/**
+ * Where a project's scry budgets stand, as `splates dev scry budgets --format json`
+ * prints it; splates only passes it on, so this mirrors the CLI's type.
+ */
+export interface Budgets {
+    /** Whether any config or change declares budgets. */
+    declared: boolean;
+    roles: RoleBudget[];
+}
+/** Where one model's budget stands. */
+export interface RoleBudget {
+    role: "som" | "llm";
+    /** Like `5m/day`, `nothing` or `unlimited`; none when undeclared. */
+    spend: string | null;
+    /** The config or file that declared it. */
+    from: string | null;
+    /** Whether it was set here, over the configs. */
+    set: boolean;
+    standing: {
+        /** Like `today` or `the last 7d`. */
+        window: string;
+        tokens: number;
+        raised: number;
+        spent: number;
+        left: number;
+    }[];
+    raises: {
+        id: number;
+        tokens: number;
+        from: number;
+        until: number;
+    }[];
+    /** The pause stopping it asking anything; none when it asks as it may. */
+    paused: {
+        from: number;
+        until: number;
+    } | null;
+}
+export declare function budgets(): Promise<Budgets>;
+/** Sets what `role` may spend here, like `5m/day`; null gives it back to the configs. */
+export declare function setBudget(role: RoleBudget["role"], spend: string | null): Promise<Budgets>;
+/** Adds `tokens`, like `2m`, to each of `role`'s limits `span`, like `1d`. */
+export declare function raiseBudget(role: RoleBudget["role"], tokens: string, span: string): Promise<Budgets>;
+/** Stops `role` asking anything for `span`, like `1d`. */
+export declare function pauseBudget(role: RoleBudget["role"], span: string): Promise<Budgets>;
+/** Lets a paused `role` ask again before its pause ends. */
+export declare function resumeBudget(role: RoleBudget["role"]): Promise<Budgets>;
+export declare function endRaise(id: number): Promise<Budgets>;
+/**
+ * Opens `path` in `editor` on this machine, inside the tree it belongs to,
+ * at `line` when there is one.
+ */
+export declare function openFile(editor: string, path: string, line: number | null): Promise<void>;

package/dev/assets.d.ts

@@ -0,0 +1,24 @@
+/** The files the browser asks for, as the server hands them over. */
+export interface Assets {
+    /** The page, which asks for the rest. */
+    shell: string;
+    /** The React app, bundled for the browser. */
+    script: string;
+    /** The React app's source map, which DevTools asks for while open. */
+    scriptMap: string;
+    /** The stylesheet, with Tailwind already compiled. */
+    styles: string;
+    /** The service worker, through which a phone shows notifications. */
+    worker: string;
+    /** The service worker's source map. */
+    workerMap: string;
+    /** The web app manifest, which makes the page installable as an app. */
+    manifest: string;
+    /** The app icon as PNG, at 192px and 512px square. */
+    icons: {
+        192: Uint8Array<ArrayBuffer>;
+        512: Uint8Array<ArrayBuffer>;
+    };
+}
+/** The page this package ships. Serve each field's contents as-is. */
+export declare const assets: Assets;

package/dev/conversation-address.d.ts

@@ -0,0 +1,47 @@
+import type { ConversationState, Setting } from "../conversations.js";
+import type { Needing } from "../needs.js";
+import type { AgentChoice } from "./conversation-feed.js";
+/** What `#conversations/task/<name>` opens: a task whose agent runs outside the page. */
+export declare const TASK = "task/";
+/** What opens `row`: its conversation's id, or its external agent's task. */
+export declare function openedBy(row: Needing): string;
+/** What `#conversations/archived` opens: every archived conversation. */
+export declare const ARCHIVED = "archived";
+/**
+ * In place of an id in the address: the screen that starts a conversation,
+ * with the agent after it, as `new/codex`, else the agent last used, and
+ * after that the task whose tree it starts in, as `new/codex/fix-upload`,
+ * else the main tree.
+ */
+export declare const NEW = "new";
+/**
+ * The conversation a `#conversations/<id>` address names, `ARCHIVED` for the
+ * archived ones, or null.
+ */
+export declare function conversationIn(hash: string): string | null;
+/**
+ * After a conversation's id in the address, as `<id>/terminal`: its terminal
+ * on a page of its own, as one of the main tree's is.
+ */
+export declare const TERMINAL = "/terminal";
+/** The address of `conversation`'s terminal on a page of its own. */
+export declare function terminalAddress(conversation: string): string;
+/**
+ * The conversation whose terminal `open` shows on a page of its own, or null.
+ * No id has a `/`, unlike the addresses of a task, a new conversation, or a
+ * main-tree terminal.
+ */
+export declare function terminalOf(open: string | null): string | null;
+/** Whether `open` is the screen that starts a conversation, with any agent. */
+export declare function startsOne(open: string | null): boolean;
+/**
+ * The agent a new conversation starts with: the one `open` names, else the
+ * newest conversation's the person picked, else the newest's, else the first.
+ */
+export declare function agentFor(open: string | null, agents: AgentChoice[], conversations: ConversationState[]): string;
+/** The user's saved defaults, independent of live session settings. */
+export declare function settingsFor(agent: string, agents: AgentChoice[], _conversations: ConversationState[]): Setting[];
+/** The task a new conversation starts in, from `open`; null for the main tree. */
+export declare function taskFor(open: string | null): string | null;
+/** The model a new conversation starts on, `?model=` in `open`, or null. */
+export declare function modelFor(open: string | null): string | null;

package/dev/conversation-feed.d.ts

@@ -0,0 +1,166 @@
+import type { Resource } from "webappwiz/disposable";
+import { type Eventful } from "webappwiz/events";
+import { type IdProvider } from "webappwiz/id";
+import { Duration, type Timer, type WallClock } from "webappwiz/time";
+import type { Attached, ConversationState, Image, Limit, Message, Setting } from "../conversations.js";
+/** How long a message goes unanswered before the page says it is still sending. */
+export declare const STILL_SENDING: Duration;
+export type ConversationFeedEvents = {
+    changed: undefined;
+};
+/** A message on its way: its words, and its files read from the page's own copies. */
+export interface Sending {
+    /**
+     * The page's id for it, sent with it for the server to keep on its own
+     * copy, which is how the page knows that copy when it comes back.
+     */
+    id: string;
+    text: string;
+    images: Image[];
+    files: Attached[];
+    /** Whether it waits for the running turn's end, as the server will record it. */
+    queued: boolean;
+    /** What the person wrote and attached, to send again or take back. */
+    typed: string;
+    attached: File[];
+    /** Whether the person said it into the mic. */
+    dictated: boolean;
+    /** When it was sent, as epoch ms, to tell when it has gone unanswered for `STILL_SENDING`. */
+    at: number;
+}
+/** A message the server refused, with why: shown until sent again or taken back. */
+export interface Unsent {
+    message: Sending;
+    why: string;
+}
+/**
+ * The page's copy of every conversation, each replaced whole as the server
+ * streams it. `available` stays false when the server holds no
+ * conversations. The phone still keeps its Inbox as home.
+ */
+export declare class ConversationFeed implements Eventful<ConversationFeedEvents>, Resource {
+    readonly timer: Timer;
+    readonly wall: WallClock;
+    private readonly ids;
+    private readonly dispatcher;
+    readonly events: import("webappwiz/events").Events<ConversationFeedEvents>;
+    /** Whether the first listing is still on its way. */
+    loading: boolean;
+    available: boolean;
+    agents: AgentChoice[];
+    /** Newest first, each with the messages on their way (see `send`) as said. */
+    conversations: ConversationState[];
+    /** Each conversation's messages on their way, by id, in the order sent. */
+    readonly sending: Map<string, Sending[]>;
+    /** Each conversation's refused messages, in the order refused, replaced whole as they change. */
+    readonly unsent: Map<string, readonly Unsent[]>;
+    /** As the server last said, without what is on its way. */
+    private recorded;
+    /**
+     * How many changes `put` and `drop` have made, and the count at each
+     * conversation's last, so a listing knows what moved while it was on its
+     * way.
+     */
+    private changes;
+    private readonly changedAt;
+    private stream;
+    /**
+     * `timer` and `wall` are what the thread waits and reads the date by;
+     * `ids` names each message on its way.
+     */
+    constructor(timer?: Timer, wall?: WallClock, ids?: IdProvider);
+    start(): void;
+    dispose(): void;
+    /** Puts `state` in place of what the page had of it, or first when new. */
+    put(state: ConversationState): void;
+    /** Drops conversation `id`, deleted as an older archived one. */
+    drop(id: string): void;
+    /**
+     * Shows `text` and `files` as said in conversation `id` before its server
+     * records them, which waits on the way there and, while the agent starts
+     * or resumes, until it is up, so the thread does not sit as it was
+     * meanwhile. Said while a turn runs, or behind another on its way, it shows
+     * as queued, as the server records it unless the agent takes it into the
+     * turn, when its echo moves it into the thread. Each goes once the server
+     * has recorded a message with its id, whatever else it records meanwhile,
+     * or `refused` keeps it as unsent. The files show from the page's own, as the server
+     * has yet to keep them. `typed` is the text as the person wrote it, before
+     * the notes on its images were added.
+     */
+    send(id: string, text: string, files?: File[], typed?: string, dictated?: boolean): Sending;
+    /**
+     * Where a message said now to conversation `id` would go, as the server
+     * last said it will take one. Every place a message is put asks here, so
+     * what decides it stays in one spot.
+     */
+    private placed;
+    /**
+     * How many of conversation `id`'s queued messages are still on their way,
+     * the last ones: the server has nothing of them to take back yet.
+     */
+    unrecorded(id: string): number;
+    /**
+     * Keeps `message`, which `send` showed in conversation `id`, as unsent at
+     * the thread's foot, since the server refused it with `error`.
+     */
+    refused(id: string, message: Sending, error: unknown): void;
+    /**
+     * Settles `message`, which `send` showed in conversation `id`, by the
+     * server's answer `state` to it: when that holds the message, the server
+     * has it, so the page takes `state` in at once if the stream has yet to
+     * bring it, and gives up any unsent copy of it.
+     */
+    answered(id: string, message: Sending, state: ConversationState): void;
+    /** Stops showing `message`, unsent in conversation `id`, to send again or edit. */
+    take(id: string, message: Sending): void;
+    /**
+     * When a message of conversation `id` next passes `STILL_SENDING`
+     * unanswered, as epoch ms; null when none will.
+     */
+    nextSlow(id: string): number | null;
+    /** Shows what is on its way afresh, as the clock now reads. */
+    recheck(): void;
+    /** Takes `message` off conversation `id`'s on their way; false when it was not. */
+    private withdraw;
+    private show;
+    private load;
+    /**
+     * Reads every conversation afresh after the stream opens, `reconnect` when it
+     * had before. Messages sent before it dropped that the listing still lacks are given up as unsent:
+     * their requests may have died with the connection, and none would say so.
+     */
+    private reopened;
+    /**
+     * Has the server ask the agents that do not send their limits for them,
+     * then reads the agents afresh, so the page shows what they said.
+     */
+    refreshLimits(): Promise<void>;
+    /** Reads every conversation afresh; false when they are off. */
+    private list;
+}
+/** An agent a conversation can be started with. */
+export interface AgentChoice {
+    id: string;
+    name: string;
+    /** The models the roster lists for it, by the ids its Model setting takes. */
+    models?: {
+        id: string;
+        name: string;
+    }[];
+    /**
+     * What its sessions last offered, from any project, each where it was
+     * left; none until it has had one on this machine.
+     */
+    settings: Setting[];
+    /**
+     * The plan's windows of use, as it last said in any project; none until
+     * it has, and never from an agent that does not say.
+     */
+    limits: Limit[];
+}
+/** What to call agent `id`: its name, or its id once it is off the roster. */
+export declare function agentName(agents: AgentChoice[], id: string): string;
+/** `message` as the thread shows it, from the page's own copies of its files. */
+export declare function messageOf(message: Sending, now?: number): Message;
+/** The images an agent that takes images is sent as such, as the server keeps them. */
+export declare const SEEN: string[];

package/dev/live-stream.d.ts

@@ -0,0 +1,29 @@
+import type { Resource } from "webappwiz/disposable";
+import { type Timer } from "webappwiz/time";
+/** What a stream's events go to, each named event by its name. */
+export interface StreamHandlers {
+    message: (event: MessageEvent<string>) => void;
+    /**
+     * On each open, `again` once it has opened before, when what moved while
+     * it was away was never said.
+     */
+    open?: (again: boolean) => void;
+    error?: () => void;
+    named?: Record<string, (event: MessageEvent<string>) => void>;
+}
+/**
+ * An `EventSource` that opens again once it has heard nothing, not even the
+ * server's pulse, for two pulses. Across a sleep a stream can sit open with
+ * no error and no news, and the page would miss every change until a reload;
+ * `open` runs again on each new one, to read afresh what moved meanwhile.
+ */
+export declare class LiveStream implements Resource {
+    private readonly url;
+    private readonly handlers;
+    private source;
+    private opened;
+    private readonly silence;
+    constructor(url: string, handlers: StreamHandlers, timer?: Timer);
+    dispose(): void;
+    private open;
+}

package/dev/worker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The page's service worker, which exists only to show notifications: a
+ * phone's browser shows one only through a worker's registration, and hears
+ * of one the server pushes while the page is frozen only through a worker.
+ * It caches nothing, since the page is only of use live.
+ *
+ * Clicking a notification focuses a window on the row's project and tells it
+ * which row to open, or, with none on that project, opens one at the row's
+ * address.
+ */
+/** What a notification carries for its click, as `Notifier.show` and a push set it. */
+export interface Opening {
+    /** The row's key, which the page looks up among its rows. */
+    key: string;
+    /** The page's address with the row open, for when no window is. */
+    url: string;
+}
+/** What the server pushes for a notice, as `Pushes` sends it. */
+export interface Pushed {
+    title: string;
+    body: string;
+    /** The row's key, which tags its notification and opens it. */
+    key: string;
+    /** The row's address, from the page's own: its `?project=` and hash. */
+    url: string;
+    /** Whether to show it even while a window of the page is in front. */
+    inFront: boolean;
+}
+/** The message a window gets when one of its notifications is clicked. */
+export interface Opened {
+    type: "splates:open";
+    key: string;
+}

package/dev-access.d.ts

@@ -0,0 +1,61 @@
+import { type WallClock } from "webappwiz/time";
+/**
+ * The Cloudflare Access application in front of `splates server`: the team it
+ * belongs to, as the issuer its tokens name, and its AUD tag. The one place
+ * both live, so whatever exposes the page beyond this machine can ask whether
+ * Access stands in front of it.
+ */
+export interface AccessConfig {
+    /** The team's own origin, `https://<team>.cloudflareaccess.com`. */
+    issuer: string;
+    /** The application's AUD tag, which each of its tokens names. */
+    aud: string;
+}
+/**
+ * The Access application `--access-team` and `--access-aud` name, or null
+ * when neither is given. The team is its name, its domain or its URL alike.
+ */
+export declare function accessConfig(team: string, aud: string): AccessConfig | null;
+/** Who a verified token says is asking. */
+export interface Identity {
+    email: string | null;
+    sub: string;
+}
+/** A request's token, verified or refused with why. */
+export type Verified = {
+    identity: Identity;
+    refused?: undefined;
+} | {
+    identity?: undefined;
+    refused: string;
+};
+/** The header Access sets on each request it lets through to the origin. */
+export declare const ACCESS_HEADER = "cf-access-jwt-assertion";
+/** The cookie a browser carries it in, which an upgrade may have alone. */
+export declare const ACCESS_COOKIE = "CF_Authorization";
+/**
+ * Checks the token Cloudflare Access hands each request against the team's
+ * signing keys, so a request that merely claims to come through Access, as
+ * any process on this machine could, gets nowhere.
+ */
+export declare class Access {
+    readonly config: AccessConfig;
+    private keys;
+    private fetching;
+    private fetchedAt;
+    private readonly fetch;
+    private readonly clock;
+    constructor(config: AccessConfig, opts?: AccessOptions);
+    /** Where the team publishes the keys its tokens are signed with. */
+    get certs(): string;
+    /** Who `request` comes from, by the token in its header or its cookie. */
+    verify(request: Request): Promise<Verified>;
+    private check;
+    private key;
+    private refetch;
+}
+/** What an `Access` reaches the world through, swapped in tests. */
+export interface AccessOptions {
+    fetch?: typeof fetch;
+    clock?: WallClock;
+}

package/dev-artifacts.d.ts

@@ -0,0 +1,22 @@
+import type { Conversation } from "./conversation.js";
+/**
+ * The version of an artifact that `request` names, `/api/conversations/<id>/
+ * artifacts/<name>/<version>`, from `conversation`: 404 `not_found` for a
+ * name or version its record lacks, and 404 `gone` for one whose bytes were
+ * deleted, so the page shows a placeholder for it.
+ */
+export declare function artifactResponse(request: Request, conversation: Conversation): Promise<Response>;
+/**
+ * Deletes the bytes of the version that `request` names, `/api/conversations/
+ * <id>/artifacts/<name>/<version>`, from `conversation`, keeping its record
+ * so the page shows a placeholder.
+ */
+export declare function deleteVersion(request: Request, conversation: Conversation): Promise<Response>;
+/**
+ * The agent's own `splates artifact add`: a form with the artifact's `name`, its
+ * `mimeType`, and its bytes as `file`. The conversation's own store keeps it,
+ * so the page hears of it as it would of any change.
+ */
+export declare function addVersion(request: Request, conversation: Conversation): Promise<Response>;
+/** The agent's own `splates artifact remove`, `/api/conversations/<id>/artifacts/<name>`. */
+export declare function removeNamed(request: Request, conversation: Conversation): Promise<Response>;

package/dev-budgets.d.ts

@@ -0,0 +1,18 @@
+import type { Project } from "./dev-project.js";
+/**
+ * The routes a project's Budget page reads and changes its scry budgets
+ * through, each answering with the report `scry budgets` prints. Spread one
+ * into a project's routes.
+ */
+export declare class BudgetRoutes {
+    #private;
+    constructor(project: Project);
+    readonly listBudgets: () => Promise<Response>;
+    /** Sets a role's spend, or with none, gives it back to the configs. */
+    readonly setBudget: (request: Request) => Promise<Response>;
+    readonly raiseBudget: (request: Request) => Promise<Response>;
+    /** Stops a role asking anything for a while, like `1d`. */
+    readonly pauseBudget: (request: Request) => Promise<Response>;
+    readonly resumeBudget: (request: Request) => Promise<Response>;
+    readonly endRaise: (request: Request) => Promise<Response>;
+}

package/dev-conversation-events.d.ts

@@ -0,0 +1,39 @@
+import type { Resource } from "webappwiz/disposable";
+import type { Logger } from "webappwiz/log";
+import type { Fs } from "webappwiz/system";
+import { type Timer } from "webappwiz/time";
+import type { Conversations } from "./conversations.js";
+import type { Journal } from "./journal.js";
+/**
+ * Hands each conversation the events its agent's splates commands logged: all
+ * of them as the server opens the project, then each new one as the journal
+ * takes it, so the page shows it in that conversation's thread at once. An
+ * event no conversation ran, an external agent's or the page's own, goes
+ * nowhere.
+ */
+export declare class ConversationEvents implements Resource {
+    #private;
+    private readonly journal;
+    private readonly conversations;
+    private readonly log;
+    private constructor();
+    /**
+     * Hands each conversation in `conversations` its events, then follows
+     * `splatesDir`, where the journal writes, for more.
+     */
+    static follow({ journal, conversations, fs, splatesDir, log, timer, }: {
+        journal: Journal;
+        conversations: Conversations;
+        fs: Fs;
+        splatesDir: string;
+        log: Logger;
+        timer?: Timer;
+    }): Promise<ConversationEvents>;
+    /**
+     * Hands out what the journal took since the last look, for when it may
+     * have changed; settles once it has.
+     */
+    changed(): Promise<void>;
+    dispose(): void;
+    private take;
+}