@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,47 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { AsyncResource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { Duration, type Timer } from "../../../core/time/index.js";
+/** Pinned, so the browser it installs is the one it launches. */
+export declare const PLAYWRIGHT_MCP = "@playwright/mcp@0.0.83";
+/**
+ * The name sessions are offered it by, which an agent's own server of that
+ * name gives way to, so its tools keep the names they had.
+ */
+export declare const BROWSER_SERVER = "playwright";
+/** How long the browser stays up with no tool call from any session. */
+export declare const IDLE: Duration;
+/**
+ * The MCP servers each agent session is offered, beyond its own.
+ */
+export interface SessionServers {
+    servers(): Promise<acp.McpServer[]>;
+}
+/**
+ * One headless browser for every agent session on the machine: a Playwright
+ * MCP over HTTP, started on the first session that asks, giving each session
+ * a browser context of its own in one chrome-headless-shell, in place of a
+ * full Chrome and an MCP per session. One that cannot start, or dies, is
+ * logged and offered to no session, which then runs its agent's own.
+ */
+export declare class SharedBrowser implements SessionServers, AsyncResource {
+    private readonly deps;
+    /** Where its config is written. */
+    private readonly dir;
+    /** The MCP while it starts or runs; null before the first ask, or once it died. */
+    private running;
+    constructor(deps: {
+        ps: Ps;
+        fs: Fs;
+        timer: Timer;
+        log: Logger;
+    }, 
+    /** Where its config is written. */
+    dir: string);
+    servers(): Promise<acp.McpServer[]>;
+    disposeAsync(): Promise<void>;
+    private start;
+    /** Where `child` listens, once it says, or null once it dies or `START_WAIT` passes. */
+    private listening;
+}

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

@@ -0,0 +1,24 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Fs, type Lock, type Ps } from "../../../core/system/index.js";
+/**
+ * Take it while an agent starts, so agents start one at a time across every
+ * splates process on this machine.
+ */
+export declare class StartLock implements Lock {
+    private readonly queue;
+    private readonly file;
+    constructor(path: string, deps: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+    });
+    /** This machine's, in `SPLATES_HOME`, `~/.splates` for none. */
+    static ofMachine(deps: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+    }): StartLock;
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+}

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

@@ -0,0 +1,91 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import { type Eventful } from "../../../core/events/index.js";
+import type { AgentProcess } from "./process";
+/** What an `AgentStream` says beyond the messages it carries. */
+export interface AgentStreamEvents extends Record<string, unknown> {
+    /** A message of the frame with this seq is being handed over. */
+    handling: number;
+    /** Every message of the frame with this seq has been dispatched. */
+    dispatched: number;
+    /** A response to a request sent before this stream, by an id under its base. */
+    stale: acp.AnyResponse;
+    /** A request this side sent, by the id it went out with. */
+    request: {
+        id: number;
+        method: string;
+    };
+}
+export interface AgentStreamOptions {
+    /**
+     * Where this side's request ids start: after a restart, give one past the
+     * highest id the log holds, so a late answer to an old request comes
+     * back as `stale` rather than as an answer to a new one.
+     */
+    base?: number;
+}
+/**
+ * ACP over an agent's frames, for the SDK's connection to read and write. It
+ * hands over one message at a time and waits for the connection to have
+ * handled it before the next, so `seq` names the frame of the message being
+ * handled while its handler runs. Lines are held until a frame ends on a
+ * newline, so a replay from past `dispatched` starts at a line and repeats
+ * none.
+ */
+export declare class AgentStream implements acp.Stream, Eventful<AgentStreamEvents> {
+    private readonly process;
+    readonly readable: ReadableStream<acp.AnyMessage>;
+    readonly writable: WritableStream<acp.AnyMessage>;
+    private readonly dispatcher;
+    readonly events: import("../../../core/events/index.js").Events<AgentStreamEvents>;
+    /** Added to every request id sent. */
+    readonly base: number;
+    private readonly frames;
+    private more;
+    private ended;
+    /** Text since the last frame that ended on a newline. */
+    private partial;
+    private _seq;
+    private _dispatched;
+    private _lastId;
+    private _asking;
+    /** Whether a frame has been handed over in part, which `detach` lets finish. */
+    private midFrame;
+    private detaching;
+    private writer;
+    private writing;
+    constructor(process: AgentProcess, { base }?: AgentStreamOptions);
+    /** The seq of the frame the message being handled came in, 0 before the first. */
+    get seq(): number;
+    /** The highest seq every message of whose frame has been handled. */
+    get dispatched(): number;
+    /** The id the last request this side sent went out with; null before the first. */
+    get lastId(): number | null;
+    /**
+     * The id of the agent's request being handled, for a handler to log
+     * what it is answering; null while the message being handled is not one.
+     */
+    get asking(): acp.JsonRpcId | null;
+    /**
+     * Stops handing messages over at the end of the frame being handled, so
+     * a log flushed after this holds whole frames only, and settles once it
+     * has: the frames after it stay with the process for the next stream.
+     */
+    detach(): Promise<void>;
+    /**
+     * Answers request `id` of the agent's as it was on the wire, for one a
+     * log holds from before this stream, which the connection never heard.
+     */
+    respond(id: acp.JsonRpcId, answer: {
+        result: unknown;
+    } | {
+        error: acp.ErrorResponse;
+    }): Promise<void>;
+    private read;
+    private pull;
+    private finish;
+    /** A response to this side's request, with the id it asked by; or null for one handed back as stale. */
+    private incoming;
+    private outgoing;
+    private send;
+    private input;
+}

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

@@ -0,0 +1,18 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { ConversationState, Tool } from "../conversations";
+/** How much of a tool call's output, and of each side of an edit, is kept. */
+export declare const TOOL_CHARS = 20000;
+/**
+ * Takes what an update says of a tool call into it. Adapters say it in
+ * different places: Claude sends a command's output whole as `rawOutput`
+ * once it ends, Codex streams it in `_meta` and says how it exited there.
+ */
+export declare function fill(tool: Tool, update: acp.ToolCall | acp.ToolCallUpdate, at: string | null): void;
+/** The tool call `id`, wherever in the conversation it was made. */
+export declare function toolIn(state: ConversationState, id: string): Tool | null;
+/** The subagent's tool call an update came from; null for the agent's own. */
+export declare function parentOf(update: {
+    _meta?: {
+        [key: string]: unknown;
+    } | null;
+}): string | null;

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

@@ -0,0 +1,46 @@
+import type { Git } from "../git";
+import { Watched } from "./watched";
+/** The git `Watch` runs, where the agent works. */
+export type WatchGit = Pick<Git, "root" | "run" | "interruptedOps" | "at">;
+/**
+ * Something a command did to git that an agent should not have, judged by
+ * what it did rather than what it said: one that stashes and pops again, or
+ * commits and squashes, did nothing worth a flag.
+ */
+export type Flag = 
+/** Stashed `count` changes and left them there. */
+{
+    type: "stashed";
+    count: number;
+}
+/** Took commits off `branch` that its tree no longer holds. */
+ | {
+    type: "dropped";
+    branch: string;
+}
+/** Checked out `now`, a branch or null for a detached HEAD, off `branch`. */
+ | {
+    type: "left";
+    branch: string;
+    now: string | null;
+}
+/** Pushed, updating these remote branches, in a command that says `push`. */
+ | {
+    type: "pushed";
+    refs: string[];
+}
+/** Changed these files in the main tree, from a task's worktree. */
+ | {
+    type: "outside";
+    paths: string[];
+};
+/**
+ * Watches the commands agents run in one repository, `git.root` its main
+ * tree, for what they did to git.
+ */
+export declare class Watch {
+    private readonly git;
+    constructor(git: WatchGit);
+    /** Starts watching a command run in `cwd`, looking at git as it stands. */
+    command(cwd: string): Watched;
+}

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

@@ -0,0 +1,43 @@
+import type { Flag, WatchGit } from "./watch";
+/** A command being watched, from the look before it ran. */
+export declare class Watched {
+    private readonly git;
+    private readonly cwd;
+    private readonly before;
+    constructor(git: WatchGit, cwd: string, before: Promise<Look>);
+    /** Starts watching a command run in `cwd`, looking at git as it stands. */
+    static start(git: WatchGit, cwd: string): Watched;
+    /** Settles once the look before the command is taken. */
+    looked(): Promise<void>;
+    /**
+     * Looks at git again, now that `command` is over, and says what it did.
+     * A push counts only in a command that says `push`.
+     */
+    done(command: string | null): Promise<Flag[]>;
+    /**
+     * Whether `branch` lost what it held at `tip`: merging that commit into
+     * what the branch is now changes nothing in its commit or its tree, as it
+     * would not after a squash or a rebase onto trunk.
+     */
+    private dropped;
+    /** A rebase detaches HEAD until it is done, as `splates merge` leaves one. */
+    private rebasing;
+    /** The remote branches a push moved, as their reflogs say. */
+    private pushed;
+}
+/** What git looked like around a command. */
+interface Look {
+    /** The stash's entries, by commit. */
+    stash: string[];
+    /** The branch HEAD is on in the command's tree, null when detached. */
+    branch: string | null;
+    /** That branch's commit; null when detached or the tree is gone. */
+    tip: string | null;
+    /** Whether the tree is gone, as a merged task's is. */
+    gone: boolean;
+    /** Every remote branch but a symbolic one like `origin/HEAD`, with its commit. */
+    remotes: Map<string, string>;
+    /** The main tree's uncommitted paths; null for a command run in it. */
+    dirty: Set<string> | null;
+}
+export {};

package/vendor/@stringsync/splates-server/artifacts/artifact.d.ts

@@ -0,0 +1,33 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { type WorktreeService } from "../tasks";
+import { type ArtifactVersion } from "./artifacts";
+/** What `fetch` is used for here, so a test can stand in for it. */
+type Send = (url: string, init: RequestInit) => Promise<Response>;
+export interface ArtifactDeps {
+    service: WorktreeService;
+    log: Logger;
+    fs: Fs;
+    ps: Ps;
+    send?: Send;
+    /** The wait between a worker's upload attempts; a test sets it to 0. */
+    retryMs?: number;
+}
+/**
+ * Keeps `file` as the next version of the artifact of that name in the
+ * conversation `id`, through the `splates server` serving this repository when
+ * the agent has one in its env, so the page hears of it, else straight into
+ * the conversation's log. On a worker (`SPLATES_WORKER` set) that log is the
+ * worker's own disk, so an upload the server never took is retried, then fails.
+ */
+export declare function addArtifact(deps: ArtifactDeps, id: string, file: {
+    name: string;
+    bytes: Uint8Array;
+}): Promise<ArtifactVersion>;
+/** Marks the artifact `name` of conversation `id` removed; answers the version that was current. */
+export declare function removeArtifact(deps: ArtifactDeps, id: string, name: string): Promise<number>;
+/** Prints what the conversation `id` holds, or, given a `name`, that artifact's versions. */
+export declare function listArtifacts(deps: ArtifactDeps, id: string, name?: string): Promise<void>;
+/** The media type `name`'s extension says, else plain bytes. */
+export declare function mimeTypeOf(name: string): string;
+export {};

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

@@ -0,0 +1,162 @@
+import { type IdProvider } from "../../../core/id/index.js";
+import type { Config } from "../config";
+import type { Storage } from "../storage";
+import type { ArtifactRoom } from "./room";
+/**
+ * A conversation's artifacts: their bytes, in `<id>/artifacts/` among the
+ * project's conversations, and their record, `held`, which each change goes to through
+ * `record` (the log, then the state) once its bytes are in place. One change
+ * at a time, so two adds of one name never take the same version.
+ */
+export declare class Artifacts {
+    /** Where every conversation of the project keeps its files, by id. */
+    private readonly storage;
+    /** The conversation's id, whose folder holds the artifacts. */
+    private readonly id;
+    private readonly deps;
+    /** Where the bytes are kept. */
+    private readonly files;
+    private readonly ids;
+    private queue;
+    constructor(
+    /** Where every conversation of the project keeps its files, by id. */
+    storage: Storage, 
+    /** The conversation's id, whose folder holds the artifacts. */
+    id: string, deps: {
+        now: () => string;
+        limits: ArtifactLimits;
+        ids?: IdProvider;
+        /** The record as it stands. */
+        held: () => Artifact[];
+        /** Keeps `change`, folding it into `held`. */
+        record: (change: ArtifactChange) => Promise<void>;
+        /**
+         * The project's room, which evicts what other versions it must
+         * for an add past the project's capacity; without it, as for a
+         * CLI that reaches no `splates server`, such an add is refused.
+         */
+        room?: ArtifactRoom;
+    });
+    /** The record as it stands. */
+    get held(): Artifact[];
+    /**
+     * Keeps `file` as the next version of the artifact named for it, listing
+     * it again if it was removed. Past the project's capacity, its room evicts
+     * what it can first; refuses one past any limit still `too_large`,
+     * changing nothing.
+     */
+    add(file: ArtifactFile): Promise<ArtifactVersion>;
+    /** Marks the artifact `name` removed, keeping every version's bytes for cleanup. */
+    remove(name: string): Promise<void>;
+    /**
+     * Deletes the bytes of `version` of the artifact `name`, saying `why`,
+     * and keeps its record, so it shows as a placeholder.
+     */
+    delete(name: string, version: number, why: ArtifactGone): Promise<void>;
+    /**
+     * Deletes the bytes of every version no longer shown, those of removed
+     * artifacts and those a later one superseded, as its conversation is
+     * archived: what stays is what its panel still lists.
+     */
+    archive(): Promise<void>;
+    /**
+     * The bytes and media type of `version` of the artifact `name`, its
+     * current one by default; null when there is no such version or its
+     * bytes are gone.
+     */
+    read(name: string, version?: number): Promise<{
+        bytes: Uint8Array;
+        mimeType: string;
+    } | null>;
+    /**
+     * Refuses `file` when it has no name, or when it or this conversation
+     * would pass its limit; its size when it fits.
+     */
+    private admit;
+    /** Writes `file`'s bytes and records them as its name's next version. */
+    private keep;
+    /** Deletes `version`'s bytes and records that they went, and why. */
+    private drop;
+    /** The artifact `name`, refusing `not_found` when there is none. */
+    private find;
+    private serially;
+}
+/**
+ * A file an agent made as an output of its conversation, such as a
+ * screenshot, a recording or an HTML page, kept by name for the life of the
+ * conversation, whatever task it was made in. Adding the name again makes its
+ * next version. Its record stays for good, so one whose bytes went still
+ * shows as a placeholder.
+ */
+export interface Artifact {
+    name: string;
+    /** The `version` of the one shown; the newest, as added. */
+    current: number;
+    /** Every version, oldest first, numbered from 1. */
+    versions: ArtifactVersion[];
+    /** When it was removed, its versions kept until cleanup takes them; null while listed. */
+    removedAt: string | null;
+}
+/** One version of an artifact: what was added under its name at once. */
+export interface ArtifactVersion {
+    version: number;
+    /** Its file in the conversation's artifacts directory, named so none collide. */
+    file: string;
+    mimeType: string;
+    /** Its size. */
+    bytes: number;
+    addedAt: string;
+    /** When and why its bytes were deleted, its record kept; null while they are kept. */
+    gone: {
+        at: string;
+        why: ArtifactGone;
+    } | null;
+}
+/**
+ * Why a version's bytes went: its conversation was archived, the project ran
+ * past its cap, or the person deleted it.
+ */
+export type ArtifactGone = "archived" | "evicted" | "deleted";
+/** A change to a conversation's artifacts, as its log keeps it. */
+export type ArtifactChange = ({
+    type: "add";
+    name: string;
+} & Omit<ArtifactVersion, "version" | "gone">) | {
+    type: "remove";
+    name: string;
+    at: string;
+} | {
+    type: "gone";
+    name: string;
+    version: number;
+    at: string;
+    why: ArtifactGone;
+};
+/** A file to keep as an artifact, as the agent hands it over. */
+export interface ArtifactFile {
+    name: string;
+    mimeType: string;
+    bytes: Uint8Array;
+}
+/** How many bytes artifacts may take, each past which an add is refused. */
+export interface ArtifactLimits {
+    /** One file. */
+    file: number;
+    /** Every version one conversation keeps the bytes of. */
+    conversation: number;
+    /** Every version every conversation in the project keeps the bytes of. */
+    project: number;
+}
+/** The limits `config` sets. */
+export declare function artifactLimits(config: Pick<Config, "artifactFileCapacity" | "artifactConversationCapacity" | "artifactProjectCapacity">): ArtifactLimits;
+/** Folds `change` into `artifacts`, as live and as a log is read back. */
+export declare function applyArtifact(artifacts: Artifact[], change: ArtifactChange): void;
+/** Whether `version` is the one its artifact's panel shows: its current, while listed. */
+export declare function shown(artifact: Artifact, version: ArtifactVersion): boolean;
+/**
+ * How many bytes every conversation in `storage` keeps, read from disk: its
+ * artifacts' and the files attached to it.
+ */
+export declare function projectBytes(storage: Storage): Promise<number>;
+/** Refuses an add that would have `what` hold `bytes`, past its `capacity`. */
+export declare function tooLarge(what: string, name: string, bytes: number, capacity: number): never;

package/vendor/@stringsync/splates-server/artifacts/attach.d.ts

@@ -0,0 +1,31 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Git } from "../git";
+import type { WorktreeService } from "../tasks";
+export interface AttachOptions {
+    /** Task whose files these are. Defaults to the one `cwd` is a worktree for. */
+    task?: string;
+    /** Files it holds to drop first, by path or by the name they were stored under. */
+    remove?: string[];
+    /**
+     * Conversation to keep the files with. Defaults to the one whose agent runs
+     * the command; with neither, they stay with the task and go when it does.
+     */
+    conversation?: string;
+}
+/**
+ * Stores files for a task's questions to show, in a folder splates owns, so
+ * the screenshots and recordings an agent takes never land in a commit.
+ * An agent in a conversation has them kept with it, so a merged task's
+ * report card still shows them; any other agent's go when the task merges or
+ * is removed. Either way, those its final `SPLATES.md` shows are copied to
+ * keep with its finished record. Prints where each was stored, which is the
+ * path a question names.
+ */
+export declare function attach(deps: {
+    service: WorktreeService;
+    git: Git;
+    log: Logger;
+    fs: Fs;
+    ps: Ps;
+}, paths: string[], cwd: string, { task, remove, conversation: given }?: AttachOptions): Promise<string[]>;

package/vendor/@stringsync/splates-server/artifacts/attachments.d.ts

@@ -0,0 +1,50 @@
+import { type IdProvider } from "../../../core/id/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Storage } from "../storage";
+/** A file handed over, as bytes so a pasted image needs no temp file. */
+export interface Attachment {
+    /** What it was called, kept in the stored name so the files stay apart. */
+    name: string;
+    bytes: Uint8Array;
+}
+/**
+ * The folder of files that belong to a task: a queued task's beside its
+ * record, in `tasks/7/`, and a started task's in `tasks/7/started/`.
+ * Under `.git/splates`, so nothing here is ever committed and every tree can
+ * open what it holds.
+ */
+export declare class Attachments {
+    private readonly storage;
+    private readonly key;
+    private readonly ids;
+    private readonly files;
+    /** Where the disk keeps the files, which a path is checked against. */
+    readonly dir: string;
+    constructor(storage: Storage, key: string, ids?: IdProvider);
+    /** Copies each file in, returning the absolute path each was stored at. */
+    store(files: Attachment[]): Promise<string[]>;
+    /** Each file stored here, by absolute path, with its size in bytes. */
+    held(): Promise<{
+        path: string;
+        bytes: number;
+    }[]>;
+    /**
+     * Whether `path` is one of this folder's files, where the disk keeps it or
+     * where `held` handed it out, and not a way out of the folder.
+     */
+    owns(path: string): Promise<boolean>;
+    /** Deletes the files given that are this folder's; others are left alone. */
+    remove(paths: string[]): Promise<void>;
+    /** Where an agent on this machine opens the file kept under `name`. */
+    private opened;
+    /** Deletes the folder and everything in it. */
+    clear(): Promise<void>;
+}
+/**
+ * Reads files named on the command line, relative to the current directory or
+ * absolute, refusing the whole command over one that cannot be read.
+ */
+export declare function readFiles({ fs, ps }: {
+    fs: Fs;
+    ps: Ps;
+}, paths: string[]): Promise<Attachment[]>;

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

@@ -0,0 +1,8 @@
+export { addArtifact, listArtifacts, removeArtifact, } from "./artifact";
+export type { Artifact, ArtifactChange, ArtifactGone, ArtifactLimits, ArtifactVersion, } from "./artifacts";
+export { Artifacts, applyArtifact, artifactLimits, } from "./artifacts";
+export { attach } from "./attach";
+export type { Attachment } from "./attachments";
+export { Attachments, readFiles } from "./attachments";
+export { ArtifactRoom } from "./room";
+export { addVersion, artifactResponse, deleteVersion, removeNamed, } from "./routes";

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

@@ -0,0 +1,38 @@
+import {
+  Artifacts2,
+  artifactLimits2,
+  applyArtifact2,
+  addArtifact2,
+  removeArtifact2,
+  listArtifacts2,
+  Attachments2,
+  readFiles2,
+  attach2,
+  ArtifactRoom2,
+  artifactResponse2,
+  deleteVersion2,
+  addVersion2,
+  removeNamed2
+} 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 {
+  ArtifactRoom2 as ArtifactRoom,
+  Artifacts2 as Artifacts,
+  Attachments2 as Attachments,
+  addArtifact2 as addArtifact,
+  addVersion2 as addVersion,
+  applyArtifact2 as applyArtifact,
+  artifactLimits2 as artifactLimits,
+  artifactResponse2 as artifactResponse,
+  attach2 as attach,
+  deleteVersion2 as deleteVersion,
+  listArtifacts2 as listArtifacts,
+  readFiles2 as readFiles,
+  removeArtifact2 as removeArtifact,
+  removeNamed2 as removeNamed
+};

package/vendor/@stringsync/splates-server/artifacts/room.d.ts

@@ -0,0 +1,46 @@
+import type { Storage } from "../storage";
+import { type Artifacts, type ArtifactVersion } from "./artifacts";
+/**
+ * Room for artifacts across a project, which every conversation's store
+ * makes its adds through, one at a time. An add past the project's capacity
+ * first evicts the bytes of other versions, in `evictionOrder`, keeping
+ * their records as placeholders; when even all of them would not make room,
+ * it is refused and nothing goes. Files attached to conversations count
+ * toward the capacity but are never evicted: they serve the questions that
+ * show them.
+ */
+export declare class ArtifactRoom {
+    private readonly deps;
+    private queue;
+    constructor(deps: {
+        /** Where every conversation of the project keeps its files, by id. */
+        storage: Storage;
+        /** How many bytes every conversation may keep together. */
+        capacity: number;
+        /** Every conversation's store, and whether it is archived. */
+        shelves: () => ArtifactShelf[];
+    });
+    /** Runs `work` once every add before it has finished. */
+    hold<T>(work: () => Promise<T>): Promise<T>;
+    /**
+     * Evicts what it must for `bytes` more of the artifact `name` to fit, or
+     * refuses `too_large`, evicting nothing, when it cannot.
+     */
+    make(bytes: number, name: string): Promise<void>;
+}
+/** One conversation's store, as the room sees it. */
+export interface ArtifactShelf {
+    store: Artifacts;
+    archived: boolean;
+}
+/**
+ * Every version whose bytes are kept, in the order eviction takes them:
+ * removed and superseded ones of any conversation first, then the shown ones
+ * of archived conversations, then those of live ones; oldest first within
+ * each.
+ */
+export declare function evictionOrder(shelves: ArtifactShelf[]): {
+    store: Artifacts;
+    name: string;
+    version: ArtifactVersion;
+}[];

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

@@ -0,0 +1,22 @@
+import type { Conversation } from "../conversations";
+/**
+ * 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>;