@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,28 @@
+export type { Cascade, CascadeStatus, CascadeStep, } from "./cascade";
+export { Cascades } from "./cascade";
+export { CascadeRoutes } from "./cascade-routes";
+export type { ShipContext } from "./commands";
+export { registeredGraph, shipsFrom } from "./commands";
+export type { ReleaseChanges } from "./git";
+export { ReleaseGit } from "./git";
+export type { Pin, ShipGraph, ShipProject, ShipSource, Use } from "./graph";
+export { publishedPins, readGraph } from "./graph";
+export type { CascadeSummary } from "./history";
+export { ShipHistory } from "./history";
+export type { LiveArtifact, LiveCheck, LiveProject, LiveVersions, ShipLiveOptions, } from "./live";
+export { REGISTRY_DEADLINE, ShipLive } from "./live";
+export { MechanicalAdoption } from "./mechanical";
+export type { ShipBump, ShipPlan, ShipStep, } from "./plan";
+export { CHANGED, changedProjects, dependencyOrder, nextPatch, nextVersion, planShip, ShipPlanError, shipName, } from "./plan";
+export { ShipRegistry } from "./registry";
+export type { ReleaseStep, ReleaseStepState, StagedPackage, } from "./release-steps";
+export { ShipRoutes } from "./routes";
+export type { Ship, ShippingOptions, ShipStatus, ShipWait } from "./run";
+export { Shipping, shipRecord } from "./run";
+export type { ShipSelection } from "./selection";
+export { SHIP_SELECTION } from "./selection";
+export { unserved } from "./served";
+export type { Stage, StageCheck, StageKey, StageLog, StageState, } from "./stages";
+export type { ShipStepsOptions, StepProject } from "./steps";
+export { ShipSteps } from "./steps";
+export { NPM_TOKEN, requestNpmToken } from "./token-request";

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

@@ -0,0 +1,40 @@
+import type { Registry } from "../../../core/ship/index.js";
+import type { Ps } from "../../../core/system/index.js";
+import { Duration } from "../../../core/time/index.js";
+import { ConfigFiles } from "../config";
+import type { ShipProject } from "./graph";
+/** Read a project's live artifacts and check whether every one serves a target version. */
+export declare class ShipLive {
+    private readonly ps;
+    private readonly configs;
+    private readonly registry;
+    constructor(ps: Pick<Ps, "spawnCapture">, opts?: ShipLiveOptions);
+    /** Read from shipStatus in the main tree, or npm latest for the graph's public packages. */
+    read(project: LiveProject): Promise<LiveVersions>;
+    /** Compare with the requested release, keeping each lagging artifact's actual version. */
+    check(project: LiveProject, version: string): Promise<LiveCheck>;
+}
+/** The graph fields needed to read a project's release status. */
+export type LiveProject = Pick<ShipProject, "root" | "version" | "packages">;
+/** Dependencies to replace when reading live versions. */
+export interface ShipLiveOptions {
+    configs?: Pick<ConfigFiles, "read">;
+    registry?: Pick<Registry, "deployed">;
+}
+/** What one release artifact serves now; null means nothing is live. */
+export interface LiveArtifact {
+    name: string;
+    deployed: string | null;
+}
+/** The local release version beside each live artifact. */
+export interface LiveVersions {
+    version: string | null;
+    artifacts: LiveArtifact[];
+}
+/** Whether all artifacts serve the requested release, and which still lag. */
+export interface LiveCheck extends LiveVersions {
+    live: boolean;
+    lagging: LiveArtifact[];
+}
+/** Default time a ship step waits for its upstream or its own release to go live. */
+export declare const REGISTRY_DEADLINE: Duration;

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

@@ -0,0 +1,30 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Ps } from "../../../core/system/index.js";
+import type { Repository } from "../records";
+import type { Cascade, CascadeStep } from "./cascade";
+import { type Pin } from "./graph";
+/** Move pins on an isolated task, then land through the same gate and merge as the CLI. */
+export declare class MechanicalAdoption {
+    private readonly repo;
+    constructor(repo: Repository & {
+        ps: Ps;
+        log: Logger;
+    });
+    run(ship: Cascade, step: CascadeStep, pins: Pin[], log: (text: string) => Promise<void>, opts: MechanicalAdoptionOptions): Promise<boolean>;
+    /**
+     * Formats the files the refresh commands rewrote with the project's Biome,
+     * which a merge gate's check refuses otherwise: `wiz update` writes
+     * `skills-lock.json` with spaces where the project indents with tabs.
+     */
+    private format;
+    /** Discard an unfinished mechanical task once the person ends its ship. */
+    discard(ship: Cascade, step: CascadeStep): Promise<void>;
+    private detail;
+    private taskOf;
+}
+export interface MechanicalAdoptionOptions {
+    afterBump: string[];
+    agent?: (task: string) => Promise<void>;
+    assigned?: () => Promise<void>;
+    signal?: AbortSignal;
+}

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

@@ -0,0 +1,14 @@
+export declare const ANSI: RegExp;
+export declare const NPM_PAGE: RegExp;
+export declare const AROUND_LINK: RegExp;
+export declare const RELEASE_PROMPT: RegExp;
+export declare const OTP_PROMPT: RegExp;
+export declare const NPM_ENV: {
+    npm_config_browser: string;
+};
+export declare function quietly(command: string): string[];
+export declare const TERMINAL: {
+    cols: number;
+    rows: number;
+};
+export declare function typedCodeError(user: string | null): string;

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

@@ -0,0 +1,90 @@
+import type { ShipGraph, ShipProject, Use } from "./graph";
+/** Why there is no plan to ship a project. */
+export declare class ShipPlanError extends Error {
+    /** The exit reason a command refuses with. */
+    readonly reason: "not_found" | "usage" | "cycle";
+    constructor(
+    /** The exit reason a command refuses with. */
+    reason: "not_found" | "usage" | "cycle", message: string);
+}
+/** How far a publish moves its project's version. */
+export type ShipBump = "patch" | "minor" | "major";
+export interface ShipStep {
+    slug: string;
+    /**
+     * `ship` runs its `ship` command and publishes; `bump` only moves its pins
+     * to the versions shipped before it.
+     */
+    action: "ship" | "bump";
+    /** The version it is at, null when its root manifest names none. */
+    from: string | null;
+    /** How far a ship moves the version; null for a dependency-only bump. */
+    bump: ShipBump | null;
+    /** The version a ship takes it to; null for a bump or an invalid version. */
+    to: string | null;
+    /** The packages a ship publishes; none for a bump. */
+    publishes: string[];
+    /** The packages it moves to their new versions, by the project shipping them. */
+    takes: Use[];
+    /** Why it ships or only takes its bump. */
+    why: string;
+}
+/**
+ * A ship of one project, or of every changed one, and everything downstream,
+ * in dependency order.
+ */
+export interface ShipPlan {
+    /** The stopped run being recovered and its confirmed publications. */
+    recovery?: {
+        id: string;
+        inputs: Use[];
+    };
+    /** The saved review approved by the person. */
+    id?: string;
+    /** The project the ship starts from, or {@link CHANGED}. */
+    from: string;
+    steps: ShipStep[];
+    /** The dependents the person left out, with what only they reach; absent for none. */
+    skipped?: string[];
+}
+/**
+ * What a ship of every project changed since its last release names as the
+ * project it starts from: no project's slug, since a slug has no `+`.
+ */
+export declare const CHANGED = "+changed";
+/** How a ship starting from `from` is named to the person. */
+export declare function shipName(from: string): string;
+/**
+ * The plan to ship `slug` at `bump`, then each project pinning a package shipped
+ * before it, in dependency order. A dependent ships at the next patch in turn
+ * when it is public, names a `ship` command and has dependents of its own to
+ * pass its new version on to; otherwise it only takes its bump. Each
+ * dependent `skip` names is left out, with whatever only it would carry the
+ * release to.
+ */
+export declare function planShip(graph: ShipGraph, slug: string, bump?: ShipBump, skip?: string[]): ShipPlan;
+/**
+ * The projects with commits on their release branch since their version tag
+ * that can ship: public, with a `ship` command. One whose history is unknown
+ * is left out, as the Ship page marks it.
+ */
+export declare function changedProjects(graph: ShipGraph): ShipProject[];
+/**
+ * The plan to ship every changed project at a patch, in dependency order,
+ * each dependent of one taking its bump first, and each project downstream
+ * as {@link planShip} carries it. A changed project ships even when nothing
+ * pins it, and even when `skip` names it: only dependents are left out.
+ */
+export declare function planChanged(graph: ShipGraph, skip?: string[]): ShipPlan;
+/** Why a dependent in a ship only takes its bump, or null when it ships too. */
+export declare function bumpOnly(project: ShipProject): string | null;
+export declare function shipStep(project: ShipProject, takes: Use[], why: string, bump?: ShipBump): ShipStep;
+/** `version` moved by `bump`; null when it is not `x.y.z`. */
+export declare function nextVersion(version: string, bump: ShipBump): string | null;
+/** `version` a patch on, as a release bumps it; null when it is not `x.y.z`. */
+export declare function nextPatch(version: string): string | null;
+/**
+ * Every project after those whose packages it pins, ties left in
+ * registration order. Throws on a cycle, which no order ships.
+ */
+export declare function dependencyOrder(graph: ShipGraph): ShipProject[];

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

@@ -0,0 +1,3 @@
+import type { Cascade } from "./cascade";
+/** Read a past ship with an id and stage list, including ships saved by older versions. */
+export declare function upgraded(cascade: Cascade): Cascade;

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

@@ -0,0 +1,29 @@
+import { Duration } from "../../../core/time/index.js";
+import type { CascadeStep } from "./cascade";
+import type { Pin } from "./graph";
+import type { ShipRegistry } from "./registry";
+/** How often the registry is asked whether a release's packages are on it. */
+export declare const POLL: Duration;
+/** How often it is asked while the release is still early, before half of the time it is expected to take. */
+export declare const EARLY_POLL: Duration;
+/** How long to wait before the next check, `waited` ms into a step expected to take `expected` ms: slow while a release is unlikely to be there yet. */
+export declare function pollAfter(waited: number, expected: number): Duration;
+/** A function giving the wait before the next check, counting from now. */
+export declare function pollSince(clock: {
+    now(): number;
+}, expected: () => number): () => Duration;
+/** What the ship command is left to do once its packages are on the registry. */
+export declare function publishedNotice(step: CascadeStep, version: string): string;
+/**
+ * Waits until every package `step` publishes is on the registry, or `settled`
+ * says the ship command is over, and shows the notice on the page when it is. The command prints nothing in that time, so this is what shows it moved on.
+ */
+export declare function untilPublished(registry: Pick<ShipRegistry, "published">, step: CascadeStep, version: string, wait: {
+    settled: () => boolean;
+    pause: () => Promise<void>;
+    show: (notice: string) => Promise<void>;
+}): Promise<void>;
+/** Whether every package `step` publishes is on the registry at `version`. */
+export declare function allPublished(registry: Pick<ShipRegistry, "published">, step: CascadeStep, version: string): Promise<boolean>;
+/** The packages `step` published, at the version it went to. */
+export declare function pinsOf(step: CascadeStep): Pin[];

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

@@ -0,0 +1,55 @@
+import type { Document, Storage } from "../storage";
+import type { ShipBump } from "./plan";
+import type { StagedPackage } from "./release-steps";
+import type { Stage, StageKey } from "./stages";
+/** Where a project's records keep its latest ship. */
+export declare function shipRecord(storage: Storage): Document<Ship>;
+/** Where a ship stands: going, or how it ended. */
+export type ShipStatus = "running" | "done" | "failed";
+/**
+ * What npm waits on the person for, on its own page: signing in, as
+ * `npm login --auth-type=web` asks, a publish's second factor, or the
+ * approval of each version a stage-only token staged.
+ */
+export interface ShipWait {
+    kind: "login" | "2fa" | "approve";
+    /** npm's page, which the person opens from any device. */
+    url: string;
+    /** When npm began waiting, as ISO time. */
+    since: string;
+    /** For `approve`: the packages staged and not yet approved. */
+    packages?: StagedPackage[];
+}
+/**
+ * A project's latest ship, kept in its records so a restarted server shows it
+ * and finishes one it left running.
+ */
+export interface Ship {
+    /** The project's slug, as `?project=` names it. */
+    project: string;
+    /** The `ship` command from its `splates.config.ts`. */
+    command: string;
+    /** The approved release type, passed to the command and kept across restarts. */
+    bump: ShipBump;
+    status: ShipStatus;
+    /** Signing in to npm first, or running the ship command. */
+    step: "login" | "ship";
+    /** The root `package.json` version as the ship started. */
+    from: string | null;
+    /** The root `package.json` version once it is done; null before. */
+    to: string | null;
+    started: string;
+    ended: string | null;
+    /** What npm waits on the person for now, or null. */
+    waiting: ShipWait | null;
+    /** The last of the output of a ship that failed. */
+    error: string | null;
+    /** How many times a restart ran it again to finish it. */
+    resumed: number;
+    /** Where its output is; the project's own `ship.log` unless its cascade named one. */
+    log?: string;
+    /** The steps it took, each with its slice of the log. */
+    stages?: Stage[];
+}
+/** The steps a ship takes itself, as {@link Ship.stages} keeps them. */
+export declare const SHIP_STAGES: StageKey[];

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

@@ -0,0 +1,13 @@
+import type { Registry } from "../../../core/ship/index.js";
+/** Exact public npm publications, with failures kept distinct from absence. */
+export declare class ShipRegistry implements Pick<Registry, "published" | "deployed"> {
+    private readonly http;
+    constructor(http?: RegistryHttp);
+    /** The npm latest dist-tag, or undefined when no latest release exists. */
+    deployed(name: string): Promise<string | undefined>;
+    published(name: string, version: string): Promise<boolean>;
+}
+/** Read-only HTTP used to confirm public npm evidence. */
+export interface RegistryHttp {
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+}

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+/** One line of the events file a ship command writes, as the Release reports it. */
+export declare const EVENT: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"declared">;
+    stage: z.ZodString;
+    packages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    deadlineMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"started">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"staged">;
+    package: z.ZodString;
+    version: z.ZodString;
+    stageId: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"check">;
+    passed: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"done">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"skipped">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    at: z.ZodString;
+    type: z.ZodLiteral<"failed">;
+    error: z.ZodString;
+}, z.core.$strip>], "type">;

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

@@ -0,0 +1,66 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Fs } from "../../../core/system/index.js";
+/**
+ * The steps a project's own Release declares, as its ship command reports
+ * them in the file named by SPLATES_SHIP_EVENTS. Called release steps here so
+ * they are not taken for a ship's per-project steps or their stages.
+ */
+export type ReleaseStepState = "pending" | "running" | "done" | "skipped" | "failed";
+/** One step of a project's Release, folded from its events. */
+export interface ReleaseStep {
+    id: string;
+    name: string;
+    /** The Release's own grouping: preflight, stamp, build, publish, tag, notes. */
+    stage: string;
+    packages: string[];
+    state: ReleaseStepState;
+    started: string | null;
+    ended: string | null;
+    /** How long it may take, in milliseconds, from the Release. */
+    deadlineMs: number;
+    /** Whether its last check passed, or null before any. */
+    checked: boolean | null;
+    error: string | null;
+    /** Packages this step staged on npm, which wait for the person to approve them. */
+    staged: StagedPackage[];
+}
+/**
+ * The release steps in an events file's `text`, in the order the Release
+ * declared them. Give it the whole file, even half written.
+ */
+export declare function readReleaseSteps(text: string): ReleaseStep[];
+/** Why a ship command failed, naming the release step that did, or null when none did. */
+export declare function releaseFailure(steps: ReleaseStep[]): string | null;
+/** An events file's text for `lines`, as a fake ship command writes it. */
+export declare function eventsText(lines: Record<string, unknown>[]): string;
+/**
+ * Follows an events file as its ship command grows it, handing `sink`
+ * the steps so far each time they change, and once more on {@link flush}. A
+ * command that writes nothing gives it nothing.
+ */
+/** Where followed release steps are kept. */
+export interface ReleaseStepsSink {
+    keep(steps: ReleaseStep[]): Promise<void>;
+}
+export declare class ReleaseStepsFollower implements Resource {
+    private readonly fs;
+    private readonly path;
+    private readonly sink;
+    private readonly timer;
+    private last;
+    private reading;
+    constructor(fs: Fs, path: string, sink: ReleaseStepsSink);
+    dispose(): void;
+    /** Reads the file a last time, once the command has ended. */
+    flush(): Promise<void>;
+    private read;
+}
+/** A package the Release staged on npm, held until the person approves it. */
+export interface StagedPackage {
+    package: string;
+    version: string;
+    /** What `npm stage approve` takes. */
+    stageId: string;
+    /** The npm page to approve it on. */
+    url: string;
+}

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

@@ -0,0 +1,14 @@
+import type { Fs } from "../../../core/system/index.js";
+import { type Timer } from "../../../core/time/index.js";
+import type { Shipping } from "./run";
+/**
+ * A project's ship over HTTP: the latest one, and its output as it prints.
+ */
+export declare class ShipRoutes {
+    #private;
+    constructor(shipping: Shipping, fs: Fs, timer?: Timer);
+    /** The latest ship, or null when the project never shipped. */
+    readonly ship: () => Promise<Response>;
+    /** What the latest ship printed, then more as it prints, ending with it. */
+    readonly shipOutput: () => Promise<Response>;
+}

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

@@ -0,0 +1,132 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { type WallClock } from "../../../core/time/index.js";
+import type { Storage } from "../storage";
+import { ReleaseGit } from "./git";
+import type { ShipBump } from "./plan";
+import { type Ship } from "./record";
+export type { Ship, ShipStatus, ShipWait } from "./record";
+export { SHIP_STAGES, shipRecord } from "./record";
+/** What a {@link Shipping} works with. */
+export interface ShippingOptions {
+    /** The project's records, which keep the ship as `ship.json`. */
+    storage: Storage;
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /** The project's main tree, where the ship command runs. */
+    root: string;
+    /** The project's directory under the splates home, which keeps the output. */
+    dir: string;
+    /** The `ship` command its `splates.config.ts` names, or null for none. */
+    command: string | null;
+    /** The project's slug. */
+    slug: () => Promise<string>;
+    clock?: WallClock;
+    /**
+     * The long-lived npm token the project's creds keep as `NPM_TOKEN`, or
+     * undefined for none. With one, the ship publishes under it and asks the
+     * person for no sign-in.
+     */
+    npmToken?: () => Promise<string | undefined>;
+    /** Asks for an `NPM_TOKEN` when a ship has none and falls back to the web login. */
+    requestNpmToken?: () => Promise<void>;
+    /** Milliseconds between looks at npm's scan of staged packages; 10 seconds by default. */
+    scanEvery?: number;
+    /** Release-branch checks; the project at root by default. */
+    git?: Pick<ReleaseGit, "sync">;
+}
+/**
+ * Runs a project's ship on the server's machine, under the person's own npm
+ * sign-in: `npm login --auth-type=web` when `npm whoami` says there is none,
+ * then the project's `ship` command from its main tree. The link each npm
+ * page asks the person to open is kept as `waiting` for the page to show,
+ * and the release's own question is answered yes, since the person asked for
+ * the ship. Its output goes to a file for the page to follow.
+ */
+export declare class Shipping implements Resource {
+    private readonly opts;
+    private readonly record;
+    private readonly clock;
+    private child;
+    private going;
+    private disposed;
+    /** Whether the person stopped the ship under way. */
+    private stopped;
+    /** Whether npm asked for a typed one-time password, which stops the ship. */
+    private typed;
+    /** Who `npm whoami` says is signed in, for the link to their 2FA settings. */
+    private user;
+    /** Where the ship under way writes its output. */
+    private log;
+    /** How many bytes its log holds, where the next step's slice begins. */
+    private bytes;
+    /** Where in the log what the child printed last began. */
+    private heardFrom;
+    /** The environment npm runs under for the ship, signed in as the person or the kept token. */
+    private npmEnv;
+    private readonly watching;
+    constructor(opts: ShippingOptions);
+    /** Where the output of a ship whose cascade names no log goes. */
+    get output(): string;
+    /** Where the ship command writes the steps of its Release. */
+    get events(): string;
+    /** Where the output of the latest ship is. */
+    outputOf(): Promise<string>;
+    /** The latest ship, going or ended, or null when the project never shipped. */
+    current(): Promise<Ship | null>;
+    /** Whether a ship runs here now. */
+    get running(): boolean;
+    /**
+     * Starts a ship at `bump`, refused while one runs or when the project
+     * names no `ship`. Its output goes to `log`, added to what is there, as a
+     * retry in a cascade's history adds to it, or else to {@link output},
+     * written afresh.
+     */
+    start(bump?: ShipBump, { log }?: {
+        log?: string;
+    }): Promise<Ship>;
+    /**
+     * Runs again a ship a server that stopped left running, which finishes it:
+     * the release's RELEASE file has it publish what it had not.
+     */
+    resume(): Promise<void>;
+    /** Waits for the ship under way, if any, to end. */
+    settled(): Promise<void>;
+    /**
+     * Stops the ship under way, as abandoning its cascade does: its command is
+     * killed and the ship ends failed. What it published stays published.
+     */
+    stop(): Promise<void>;
+    dispose(): void;
+    private run;
+    private steps;
+    private releaseStepsOf;
+    /** A visible gate before publishing, and a check that the release commit reached origin. */
+    private sync;
+    /**
+     * Follows `child` to its exit: its output to the file, each npm link it
+     * prints as what the ship waits on, cleared once npm says anything else,
+     * and the release's question answered yes.
+     */
+    private watch;
+    private line;
+    private end;
+    /** npm asked for a publish's second factor: its step waits on the person. */
+    private asked;
+    /** npm moved on from what it waited on the person for. */
+    private answered;
+    /** `stage` ended now in `state`, its log slice closed where the log is. */
+    private closed;
+    /** Changes the step `key` of the ship under way, kept by a ship that has steps. */
+    private stage;
+    /** Adds `text` to the ship's log, counting where the next slice begins. */
+    private say;
+    private update;
+    /** The root `package.json` version, or null when it has none. */
+    private version;
+    /** The last lines of the output, or `otherwise` when it printed nothing. */
+    private tail;
+    private stamp;
+}

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { Cascade } from "./cascade";
+import type { ShipGraph, ShipProject } from "./graph";
+import { type ShipHistory } from "./history";
+/** The person's choices; versions and dependency edges are always computed on the server. */
+export declare const SHIP_SELECTION: z.ZodObject<{
+    projects: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        bump: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+        }>;
+        deps: z.ZodDefault<z.ZodBoolean>;
+        ship: z.ZodDefault<z.ZodBoolean>;
+        adopt: z.ZodDefault<z.ZodEnum<{
+            agent: "agent";
+            mechanical: "mechanical";
+        }>>;
+        instructions: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The choices as sent: `deps`, `ship` and `adopt` default when left out. */
+export type ShipSelection = z.input<typeof SHIP_SELECTION>;
+type ParsedSelection = z.output<typeof SHIP_SELECTION>;
+/** Calculate target versions and dependency edges from the person's project choices. */
+export declare class ShipSelections {
+    private readonly history;
+    constructor(history: ShipHistory);
+    create(graph: ShipGraph, selection: ParsedSelection, started: string): Promise<SelectedShip>;
+}
+export interface SelectedShip {
+    cascade: Cascade;
+    projects: ShipProject[];
+}
+export {};

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

@@ -0,0 +1,4 @@
+import type { Registry } from "../../../core/ship/index.js";
+import type { Pin } from "./graph";
+/** The exact upstream versions npm does not serve yet. */
+export declare function unserved(registry: Pick<Registry, "published">, pins: Pin[]): Promise<string[]>;