@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,235 @@
+import type { SecretStore } from "../../../core/creds/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Config } from "../config";
+import type { ReplicaStatus } from "../replica";
+import type { WorkerListing } from "../workers";
+import { type FieldProgress, type StepField } from "./fields";
+import type { OpenCodeSetup } from "./opencode";
+import { type StepUndo, type UndoPlan } from "./undo";
+/**
+ * Setting splates up on this machine: the roster's steps, which the user has
+ * skipped, kept in `~/.splates/setup.json` so a skipped step stops asking, and
+ * where each stands.
+ */
+export declare class Setup {
+    #private;
+    constructor(machine: SetupMachine, areas: readonly SetupArea[]);
+    /** The step `id` names, one a step stands for on this machine among them, refusing one not on the roster. */
+    step(id: string): Promise<SetupStep>;
+    /**
+     * Does a step's work with the answers from its page, then checks it, and
+     * answers the fresh progress. Throws a `StepProblem`, one line for the
+     * page, when an answer is missing, the work fails or the step still reads
+     * not done.
+     */
+    submit(id: string, answers: StepAnswers): Promise<SetupProgress>;
+    /** Every step checked, by area, and the one to do next. */
+    read(): Promise<SetupProgress>;
+    /** Stops `id` asking, until `unskip`. */
+    skip(id: string): Promise<void>;
+    /** Asks for `id` again. */
+    unskip(id: string): Promise<void>;
+    /**
+     * Marks setup as seen on this machine, so the page stops nudging a fresh
+     * one towards it.
+     */
+    see(): Promise<void>;
+    /** What undoing area `id` would do, as `SetupUndo` plans it. */
+    undoPlan(id: string): Promise<UndoPlan>;
+    /**
+     * Undoes area `id`, `confirm` the name its plan asks typed, answering
+     * the fresh progress; a `StepProblem` when it will not go.
+     */
+    undo(id: string, confirm: string | null): Promise<SetupProgress>;
+}
+/** What a step's check reads: this machine's splates home and its device store. */
+export interface SetupMachine {
+    /** Runs OpenCode's checks for the optional native setup panel, only when it asks. */
+    opencode?: OpenCodeSetup;
+    fs: Fs;
+    /** How a step runs a program, as `claude --version`; none runs nothing. */
+    ps?: Ps;
+    /** `~/.splates`, or a test's own. */
+    home: string;
+    /** The device's secret store, where creds kept for every project live. */
+    device: SecretStore;
+    /** How a check reaches the network, as for Access; the global one by default. */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * The project setup is opened from, for the steps that set up its
+     * repository rather than the machine; none outside one.
+     */
+    project?: SetupProject;
+    /** The workers `splates server` lists, for the steps that read the pool; none with no server to ask. */
+    workers?(): Promise<readonly SetupWorker[]>;
+    /**
+     * Removes worker `id` from the pool, revoking its key, as `splates worker
+     * remove` does; one with agents on it drains first. None with no server.
+     */
+    removeWorker?(id: string): Promise<void>;
+    /**
+     * Deletes what `splates tunnel setup` and the slots made in Cloudflare and
+     * forgets their saved files, as `splates tunnel remove` does. None outside
+     * a project, whose creds it reads the API token through.
+     */
+    removeTunnel?(): Promise<void>;
+}
+/** A worker as a step reads it, from `GET /api/workers`. */
+export type SetupWorker = Pick<WorkerListing, "id" | "kind" | "draining" | "removing" | "host">;
+/** What a step that sets up a repository reads of its project, afresh each time. */
+export interface SetupProject {
+    readonly root: string;
+    /** Its `splates.config.ts`, as it stands now. */
+    config(): Promise<Pick<Config, "trunk" | "remote" | "replica" | "evals">>;
+    /** The URL `remote` fetches from, or null when there is no such remote. */
+    remoteUrl(remote: string): Promise<string | null>;
+    /**
+     * Where its replica stands: as of now while `splates server` keeps it,
+     * else as of its last batch; null when none has run. None when its
+     * records cannot be read.
+     */
+    replica?(): Promise<ReplicaStatus | null>;
+    /** Whether its creds, the project's then the device's, keep `name`. None when they cannot be read. */
+    kept?(name: string): Promise<boolean>;
+}
+/**
+ * One thing to set up, small enough that you do at most one thing for it. It
+ * shows as done while its check against real state passes, so a step you undo
+ * by hand shows as left again.
+ */
+export interface SetupStep {
+    /** How `splates setup <step>` and the page name it, lowercase-with-dashes. */
+    readonly id: string;
+    readonly title: string;
+    /** Why it matters, in a sentence. */
+    readonly why: string;
+    /** The one thing the user does, in markdown. */
+    readonly user: string;
+    /** What the agent walking the user through it does, in markdown. */
+    readonly agent: string;
+    /** An optional step can be left undone for good; a required one cannot. */
+    readonly optional: boolean;
+    /** The steps that must be done first, on the roster before this one. */
+    readonly after: readonly SetupStep[];
+    /** Whether it is done, from real state. */
+    check(machine: SetupMachine): Promise<boolean>;
+    /** Whether the roster lists it at all on this machine; always when absent. */
+    shown?(machine: SetupMachine): Promise<boolean>;
+    /**
+     * The steps it stands for on this machine, as one per GitHub owner its
+     * projects are under, which the roster lists in its place, each with an
+     * id of its own and `of` it. Its own check says whether all are done,
+     * for the steps `after` it, and its undo takes them all back.
+     */
+    each?(machine: SetupMachine): Promise<readonly SetupStep[]>;
+    /** The step it is one of, when made by that step's `each`. */
+    readonly of?: SetupStep;
+    /** Markdown on this machine's own state for the step, as what a choice costs; none when absent. */
+    detail?(machine: SetupMachine): Promise<string | null>;
+    /**
+     * Markdown on what wants putting right though the step may be done, and
+     * how, as a root key signing in; null when nothing does, and none when
+     * absent. The page stops on a step while it has one.
+     */
+    warning?(machine: SetupMachine): Promise<string | null>;
+    /**
+     * What the step's own page body draws, as JSON, as the deploy keys to
+     * add; none when absent. Only a step the page draws itself has one.
+     */
+    data?(machine: SetupMachine): Promise<StepData | null>;
+    /**
+     * What its page asks, in order, or how to read it on this machine, as
+     * the token of the cloud chosen; none when the user does the step
+     * outside the page, as signing in on a phone, and Next only checks.
+     */
+    readonly fields?: readonly StepField[] | ((machine: SetupMachine) => Promise<readonly StepField[]>);
+    /**
+     * Does what the step needs once the user presses Next, each cred field
+     * already saved for the device: runs an install, writes the roster. Throws an
+     * error whose message is one line the page shows. Without one, Next only
+     * checks.
+     */
+    submit?(machine: SetupMachine, answers: StepAnswers): Promise<void>;
+    /** A line on what `submit` runs, as "Installing OpenCode with npm…". */
+    readonly doing?: string;
+    /**
+     * How to take the step back out, run when its area is undone; without
+     * one, undoing only forgets its creds.
+     */
+    readonly undo?: StepUndo;
+    /**
+     * What the step needs to go on working, or to be undone, that others
+     * share: creds, as the token a box is destroyed with.
+     * Undoing another area keeps each while this step is done, and undoing
+     * this one forgets its creds.
+     */
+    readonly uses?: readonly string[];
+    /**
+     * What the page says when Next finds the step still not done, as "Sign
+     * in on your phone, then press Next."
+     */
+    readonly notDone?: string;
+}
+/** What the user answered on a step's page, by field name. */
+export type StepAnswers = Record<string, string | boolean>;
+/** A part of setup, such as remote access, and its steps in order. */
+export interface SetupArea {
+    readonly id: string;
+    readonly title: string;
+    /** What the area is for, in a sentence. */
+    readonly purpose: string;
+    readonly steps: readonly SetupStep[];
+}
+/** A step's state: done and skipped are settled, ready can go now, waiting cannot yet. */
+export type StepStatus = "done" | "skipped" | "ready" | "waiting";
+/** A step as `splates setup --json` and `GET /api/setup` give it. */
+export interface StepProgress {
+    id: string;
+    title: string;
+    why: string;
+    user: string;
+    agent: string;
+    optional: boolean;
+    after: string[];
+    status: StepStatus;
+    /** What went wrong checking it, or null when the check ran. */
+    problem: string | null;
+    /** The cred the user pastes for it, or null. */
+    cred: string | null;
+    /** What its page asks. */
+    fields: FieldProgress[];
+    /** A line on what its Next runs, or null. */
+    doing: string | null;
+    /** Markdown on this machine's state for it, or null. */
+    detail: string | null;
+    /** Markdown on what wants putting right, and how, or null. */
+    warning: string | null;
+    /** What its own page body draws, or null. */
+    data: StepData | null;
+}
+/** What a step hands its own page body, as JSON. */
+export type StepData = Record<string, unknown>;
+export interface AreaProgress {
+    id: string;
+    title: string;
+    /** What the area is for, in a sentence. */
+    purpose: string;
+    /** Whether every step can be left undone, so the area is not needed. */
+    optional: boolean;
+    done: number;
+    skipped: number;
+    /** Steps neither done nor skipped. */
+    left: number;
+    /** Whether a step is done or started, so Undo has something to take out. */
+    undoable: boolean;
+    steps: StepProgress[];
+}
+export interface SetupProgress {
+    areas: AreaProgress[];
+    /** The one step to do next, or null when nothing is ready. */
+    next: string | null;
+    /** Whether no one has opened setup on this machine yet. */
+    fresh: boolean;
+    /** Whether any required step is neither done nor skipped. */
+    required: boolean;
+}

package/vendor/@stringsync/splates-server/setup/step-problem.d.ts

@@ -0,0 +1,3 @@
+/** Why a setup step's Next did not go through, in one line the page shows. */
+export declare class StepProblem extends Error {
+}

package/vendor/@stringsync/splates-server/setup/undo.d.ts

@@ -0,0 +1,80 @@
+import type { SetupArea, SetupMachine, SetupStep } from "./setup";
+/**
+ * Taking a setup area back out: the undo of each step done or started, last
+ * first, then the creds they saved, but for one a step still done elsewhere
+ * uses. A step not done is started when it left a cred of its own saved, as
+ * a journey left partway does.
+ */
+export declare class SetupUndo {
+    #private;
+    constructor(machine: SetupMachine, areas: readonly SetupArea[]);
+    /**
+     * What undoing area `id` would do: each step it undoes, last first,
+     * with what that removes and what only the person can; the creds it
+     * forgets and those it keeps for a step still using them; the name to
+     * type when it destroys something costly; and why it cannot, if it cannot.
+     */
+    plan(id: string): Promise<UndoPlan>;
+    /**
+     * Undoes area `id`: runs each of its steps' undo, last first, then forgets
+     * the creds `undoPlan` says it forgets. Throws a `StepProblem` when the
+     * plan refuses, `confirm` is not the name it asks for, or a step's undo
+     * fails, which leaves the rest as they were, so undoing again goes on
+     * from there.
+     */
+    run(id: string, confirm: string | null): Promise<void>;
+    /**
+     * Whether area `id` has anything to undo, given the steps `done` across
+     * every area, as `Setup.read` has them.
+     */
+    undoable(id: string, done: ReadonlySet<SetupStep>): Promise<boolean>;
+}
+/**
+ * Taking a step back out, done or started. Its `run` passes over what is
+ * gone already, or never made, so undoing again after a failure, or a step
+ * left partway, finishes the job.
+ */
+export interface StepUndo {
+    /**
+     * What `run` removes, a line each, naming each thing, for the page to
+     * list first; `kept` names what others share that a step elsewhere
+     * still uses, as the cloud chosen, which it leaves.
+     */
+    removes(machine: SetupMachine, kept?: ReadonlySet<string>): Promise<readonly string[]>;
+    /** What only the person can remove, a markdown line each with where to. */
+    leaves?(machine: SetupMachine): Promise<readonly string[]>;
+    /** Why it cannot be undone here now, or null. */
+    refused?(machine: SetupMachine): Promise<string | null>;
+    /** A name the person types to go ahead, for something costly to lose; none for null. */
+    confirm?(machine: SetupMachine): Promise<string | null>;
+    /**
+     * Removes what the step made, but what `kept` names, its creds still
+     * kept, which the area's undo forgets after.
+     */
+    run(machine: SetupMachine, kept?: ReadonlySet<string>): Promise<void>;
+}
+/** What undoing an area would do, as `GET /api/setup/:area/undo` gives it. */
+export interface UndoPlan {
+    area: string;
+    title: string;
+    /** Each step it undoes, done or started, last first. */
+    steps: StepUndoPlan[];
+    creds: UndoCred[];
+    /** The name to type to go ahead, or null for none. */
+    confirm: string | null;
+    /** Why it cannot be undone now, or null. */
+    refused: string | null;
+}
+export interface StepUndoPlan {
+    id: string;
+    title: string;
+    /** Whether it is done, not just started. */
+    done: boolean;
+    removes: string[];
+    leaves: string[];
+}
+/** A cred an undo would forget, unless `keptFor` names what still uses it. */
+export interface UndoCred {
+    name: string;
+    keptFor: string | null;
+}

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

@@ -0,0 +1,57 @@
+import type { Ps } from "../../../core/system/index.js";
+import type { Ship } from "./record";
+import type { ReleaseStep } from "./release-steps";
+import { type Stage, type StageKey } from "./stages";
+/**
+ * Whether npm's scan of a staged package still runs, from the JSON of
+ * `npm stage view <stage-id> --json`, and the status it read.
+ */
+export declare function scanning(json: string): {
+    scanning: boolean;
+    status: string;
+};
+/** What an {@link ApprovalWatch} reaches the ship through. */
+export interface ApprovalWatchOptions {
+    ps: Ps;
+    root: string;
+    /** Milliseconds between looks at npm's scan. */
+    every: number;
+    now: () => number;
+    /** The environment npm runs under, signed in. */
+    env: () => Record<string, string>;
+    /** Who is signed in to npm, if known. */
+    user: () => string | null;
+    /** Whether the server is stopping. */
+    stopped: () => boolean;
+    /** Where in the ship log the output last heard began. */
+    from: () => number;
+    /** How many bytes the ship log holds. */
+    bytes: () => number;
+    read: () => Promise<Ship | null>;
+    update: (change: Partial<Ship>) => Promise<void>;
+    stage: (key: StageKey, change: (stage: Stage) => Stage) => Promise<void>;
+}
+/**
+ * Holds a ship's wait on the person to approve what its release staged
+ * until npm has finished scanning it, so the push says the packages are
+ * ready to approve rather than that they are staged.
+ */
+export declare class ApprovalWatch {
+    private readonly opts;
+    /** The steps of the release as they last stood. */
+    private latest;
+    /** The poll of npm's scan, while one runs. */
+    private scan;
+    constructor(opts: ApprovalWatchOptions);
+    /** The release's steps now stand as `steps`. */
+    keep(steps: ReleaseStep[]): Promise<void>;
+    /** Sets the wait on the person for what is staged, or ends it once it is approved. */
+    private approved;
+    /**
+     * Polls `npm stage view` for each staged package until npm's scan of all
+     * of them is over, then asks the person, which pushes once. A package
+     * whose view fails counts as scanned, since the person can still look.
+     */
+    private scanned;
+    private stamp;
+}

package/vendor/@stringsync/splates-server/ship/approval.d.ts

@@ -0,0 +1,17 @@
+import type { Ship, ShipWait } from "./record";
+import type { ReleaseStep, StagedPackage } from "./release-steps";
+/**
+ * The staged packages whose approval the release still waits on: those with
+ * an approve step that has not ended.
+ */
+export declare function awaitingApproval(steps: ReleaseStep[]): StagedPackage[];
+/**
+ * What the ship's record changes to as the release's `steps` stand, or null
+ * for no change: the wait on the person to approve `packages`, or none once
+ * they are approved.
+ */
+export declare function approvalChange(waiting: Ship["waiting"], steps: ReleaseStep[], now: string, user?: string | null): {
+    waiting: ShipWait | null;
+} | null;
+/** The npm page that lists what `user` has staged, or null when who is signed in is unknown. */
+export declare function stagedPackagesUrl(user: string | null): string | null;

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

@@ -0,0 +1,25 @@
+import { type Timer } from "../../../core/time/index.js";
+import type { Cascades } from "./cascade";
+/** Legacy ship history and the live feed retained for ship displays. */
+export declare class CascadeRoutes {
+    #private;
+    constructor(cascades: Cascades, timer?: Timer);
+    private steps;
+    readonly start: (request: Request) => Promise<Response>;
+    readonly retry: () => Promise<Response>;
+    readonly handToAgent: () => Promise<Response>;
+    readonly abandon: () => Promise<Response>;
+    /** The cascade under way, or the last to end, or null when none ran. */
+    readonly cascade: () => Promise<Response>;
+    /** The cascades history keeps, newest first, each without its steps. */
+    readonly history: () => Promise<Response>;
+    /** The cascade `/api/ship/history/<id>` names, with its steps and the ship under way. */
+    readonly historyEntry: (request: Request) => Promise<Response>;
+    /** What the step `?stage=` of `?project=`'s part in the cascade printed. */
+    readonly historyLog: (request: Request) => Promise<Response>;
+    /**
+     * The cascade under way or the last to end, with its ship, as server-sent
+     * events: once as the page joins, then each time it changes.
+     */
+    readonly cascadeEvents: () => Promise<Response>;
+}

package/vendor/@stringsync/splates-server/ship/cascade.d.ts

@@ -0,0 +1,70 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Storage } from "../storage";
+import type { Pin } from "./graph";
+import { ShipHistory } from "./history";
+import type { ShipStep } from "./plan";
+import type { Ship } from "./run";
+import type { Stage, StageKey } from "./stages";
+/** A past ship and the outcome of each project it included. */
+export interface Cascade {
+    /** What history keeps it under. */
+    id: string;
+    /** The project it started from, or {@link CHANGED}. */
+    from: string;
+    /**
+     * `done` once every project is done or dropped, `stopped` once one
+     * failed or its bump task went unmerged, `abandoned` once the person
+     * ended it; whatever had shipped stays shipped.
+     */
+    status: "running" | "done" | "stopped" | "abandoned";
+    started: string;
+    ended: string | null;
+    /** In dependency order, as the plan the person approved had them. */
+    steps: CascadeStep[];
+}
+/**
+ * Where one project of a cascade stands: `waiting` on the projects it takes
+ * from, `registry` while npm does not yet serve the versions its bump takes,
+ * `bumping` while its bump task is open, `asking` while that task
+ * waits on the person, `stopped` once that task was removed unmerged,
+ * `shipping` while its ship runs, `failed` once the ship failed, `done`,
+ * `dropped` when it has nothing to take, or `abandoned` with the whole run.
+ * A stopped or failed project stops the whole run.
+ */
+export type CascadeStatus = "waiting" | "registry" | "bumping" | "asking" | "stopped" | "shipping" | "failed" | "done" | "dropped" | "abandoned";
+/** One project's part in a cascade, as its plan named it and how far it came. */
+export interface CascadeStep extends ShipStep {
+    /** How this step adopts upstream versions; agent adoption waits for its task to merge. */
+    adopt?: "mechanical" | "agent";
+    instructions?: string;
+    /** Merge gate failure retained when handing mechanical adoption to an agent. */
+    adoptFailure?: string;
+    status: CascadeStatus;
+    /** When it first found its bump's versions not yet served by npm, while `registry`. */
+    registrySince?: string;
+    /** Its bump task's number in its own project, once added. */
+    task: number | null;
+    /** When its ship started, as its project's `ship.json` has it, once started. */
+    ship: string | null;
+    /** What its ship published, at the versions it went to, once done. */
+    published: Pin[];
+    /** Why it stopped, failed or was dropped; null otherwise. */
+    note: string | null;
+    /** Its steps in the order it takes them, each with its times, last check and log. */
+    stages: Stage[];
+}
+/** Browse past ships and their logs with `kept` and `stageLog`; no old run resumes. */
+export declare class Cascades {
+    readonly history: ShipHistory;
+    constructor(storage: Storage, fs: Fs);
+    current(): Promise<Cascade | null>;
+    shown(): Promise<{
+        cascade: Cascade | null;
+        ship: Ship | null;
+    }>;
+    kept(id: string): Promise<{
+        cascade: Cascade;
+        ship: Ship | null;
+    } | null>;
+    stageLog(id: string, slug: string, key: StageKey): Promise<string | null>;
+}

package/vendor/@stringsync/splates-server/ship/commands.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { ConfigFiles } from "../config";
+import type { Git } from "../git";
+import type { Projects } from "../projects";
+import { type ShipGraph } from "./graph";
+/** Dependencies for reading registered shipping projects. */
+export interface ShipContext {
+    projects: Pick<Projects, "list">;
+    git: Pick<Git, "root">;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /** What each project's `ship` is read from; its `splates.config.ts` by default. */
+    configs?: Pick<ConfigFiles, "read">;
+}
+/**
+ * Whether the project at `root` can be shipped: its `splates.config.ts`
+ * names a `ship` command and it publishes a public package.
+ */
+export declare function shipsFrom(ctx: Pick<ShipContext, "fs" | "configs">, root: string): Promise<boolean>;
+/**
+ * The graph of every registered project still on disk, to plan a ship
+ * across them, each with the `ship` its `splates.config.ts` names.
+ */
+export declare function registeredGraph(ctx: Pick<ShipContext, "projects" | "fs" | "log" | "configs"> & Partial<Pick<ShipContext, "ps">>): Promise<ShipGraph>;

package/vendor/@stringsync/splates-server/ship/git.d.ts

@@ -0,0 +1,31 @@
+import type { Ps } from "../../../core/system/index.js";
+/** Commits on the release branch since its version tag, or why that is unknown. */
+export type ReleaseChanges = {
+    commits: number;
+    branch: string;
+    tag: string;
+    error: null;
+} | {
+    commits: null;
+    branch: string | null;
+    tag: string | null;
+    error: string;
+};
+/** Git checks specific to shipping, using the same origin and version tags as webappwiz. */
+export declare class ReleaseGit {
+    private readonly ps;
+    private readonly root;
+    constructor(ps: Ps, root: string);
+    /** Count unshipped commits since `version`, or explain why its release history is unknown. */
+    changes(version: string | null): Promise<ReleaseChanges>;
+    /**
+     * Whether `version`'s release tag is on the remote, or the project tags no
+     * releases there at all, so a release that died before its tag is told apart.
+     */
+    tagged(version: string): Promise<boolean>;
+    /** Pushes only a clean, fast-forward release branch and checks the remote's actual ref. */
+    sync(): Promise<string>;
+    private branch;
+    private run;
+    private out;
+}

package/vendor/@stringsync/splates-server/ship/graph.d.ts

@@ -0,0 +1,60 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { ReleaseChanges } from "./git";
+/**
+ * Draws the graph of `sources` from each one's root and workspace
+ * `package.json` files: the public packages each publishes, and the versions
+ * each pins of the others'. A `workspace:` pin is the project's own and
+ * draws no edge.
+ */
+export declare function readGraph(fs: Fs, sources: ShipSource[]): Promise<ShipGraph>;
+/**
+ * The public packages the project at `root` publishes, each at the version
+ * its manifest names now: what a ship that ended there published.
+ */
+export declare function publishedPins(fs: Fs, root: string): Promise<Pin[]>;
+/** A registered project the graph is drawn over. */
+export interface ShipSource {
+    slug: string;
+    root: string;
+    /** Its `splates.config.ts`'s `ship`, null when it is never shipped. */
+    ship: string | null;
+}
+/** A package one project pins of another's, at the version it pins. */
+export interface Pin {
+    name: string;
+    version: string;
+}
+/** One project's use of another's packages. */
+export interface Use {
+    /** The other project's slug. */
+    project: string;
+    /** The other's packages it pins, by name. */
+    pins: Pin[];
+}
+/** A registered project, as shipping sees it. */
+export interface ShipProject extends ShipSource {
+    /** Local commits since the current version tag; absent from older graph responses. */
+    changes?: ReleaseChanges;
+    /** The root manifest's version, null when it names none. */
+    version: string | null;
+    /** The public packages it publishes, by name. */
+    packages: string[];
+    /** It publishes nothing: every package it has is private. */
+    private: boolean;
+    /** The projects whose packages it pins. */
+    uses: Use[];
+    /** The projects pinning its packages. */
+    dependents: Use[];
+}
+/** Every registered project and who pins whose packages, in registration order. */
+export interface ShipGraph {
+    projects: ShipProject[];
+}
+/**
+ * Moves every pin of `pins` in the `package.json` files under `root` (the
+ * root's and each workspace member's) to its version, keeping the range
+ * mark it had; a `workspace:` pin is left alone. The files it changed.
+ */
+export declare function movePins(fs: Fs, root: string, pins: Pin[]): Promise<string[]>;
+/** Whether every target is already pinned everywhere it occurs in the base manifests. */
+export declare function pinsMatch(fs: Fs, root: string, pins: Pin[]): Promise<boolean>;

package/vendor/@stringsync/splates-server/ship/history.d.ts

@@ -0,0 +1,51 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Storage } from "../storage";
+import type { Cascade } from "./cascade";
+import { type StageKey, type StageLog } from "./stages";
+/** How many cascades history keeps, the one under way among them. */
+export declare const KEPT = 20;
+/** What a cascade is in the history list, without its steps. */
+export interface CascadeSummary {
+    id: string;
+    from: string;
+    status: Cascade["status"];
+    started: string;
+    ended: string | null;
+    /** Each project in it and where it stands, in dependency order. */
+    projects: {
+        slug: string;
+        status: string;
+    }[];
+}
+/** The ships the machine ran lately, the last {@link KEPT} of them with their steps and logs, for the page to list and open. */
+export declare class ShipHistory {
+    private readonly storage;
+    private readonly fs;
+    constructor(storage: Storage, fs: Fs);
+    /** Keeps `cascade` as it stands now. */
+    file(cascade: Cascade): Promise<void>;
+    /** The cascade `id` names, or null when history has none. */
+    read(id: string): Promise<Cascade | null>;
+    /** Every cascade kept, newest first. */
+    list(): Promise<Cascade[]>;
+    /** Every cascade kept, newest first, without its steps. */
+    summaries(): Promise<CascadeSummary[]>;
+    /** Where the ship log of `slug` in the cascade `id` is. */
+    logOf(id: string, slug: string): string;
+    /** What the ship log of `slug` in the cascade `id` holds at `log`'s bytes, to its end while it prints. */
+    slice(id: string, slug: string, log: StageLog): Promise<string>;
+    /** Drops all but the newest {@link KEPT} cascades, with their logs. */
+    prune(): Promise<void>;
+    /**
+     * How long step `key` of `slug`'s part is expected to take: the mean of
+     * the last few times it was done, known, or else its default.
+     */
+    expected(slug: string, key: StageKey, kept?: Cascade[]): Promise<{
+        expected: number;
+        known: boolean;
+    }>;
+    /** The ids kept, oldest first, as their start sorts them. */
+    private ids;
+}
+/** The id a cascade from `from`, started at `started`, is kept under. */
+export declare function cascadeId(from: string, started: string): string;