@stringsync/splates 0.0.61 → 1.13.3

package/vendor/core/push/pusher.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Where a browser asked to be pushed to, as `PushSubscription.toJSON()` gives
+ * it: the push service's endpoint, and the keys a message is encrypted to.
+ */
+export interface Subscription {
+    endpoint: string;
+    keys: {
+        /** The browser's P-256 public key, base64url. */
+        p256dh: string;
+        /** Its 16-byte authentication secret, base64url. */
+        auth: string;
+    };
+}
+export interface PushOptions {
+    /** How long the push service keeps a message for an offline device; a day by default. */
+    ttlSecs?: number;
+    urgency?: "very-low" | "low" | "normal" | "high";
+    /** A newer message with the same topic replaces one still undelivered. */
+    topic?: string;
+}
+/** Sends a message to a browser's push subscription, for its service worker. */
+export interface Pusher {
+    push(subscription: Subscription, payload: string, opts?: PushOptions): Promise<void>;
+}

package/vendor/core/push/vapid.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The key pair a server signs its pushes with (RFC 8292), each base64url:
+ * the public key as an uncompressed P-256 point, which the page subscribes
+ * with as `applicationServerKey`, and the private key's scalar.
+ */
+export interface VapidKeys {
+    publicKey: string;
+    privateKey: string;
+}
+/** Makes a new pair, to keep: every subscription made with it needs it. */
+export declare function generateVapidKeys(): Promise<VapidKeys>;
+/**
+ * The `Authorization` header for a push to `endpoint`: a JWT for its origin,
+ * signed with `keys`, naming `subject` (a `mailto:` or `https:` URL) for the
+ * push service to reach about it, good until `expiresAt` (epoch ms, at most
+ * a day off).
+ */
+export declare function vapidAuthorization(keys: VapidKeys, endpoint: string, subject: string, expiresAt: number): Promise<string>;

package/vendor/core/push/web-pusher.d.ts

@@ -0,0 +1,20 @@
+import { type WallClock } from "../time/index.js";
+import type { Pusher, PushOptions, Subscription } from "./pusher";
+import { type VapidKeys } from "./vapid";
+export interface WebPusherOptions {
+    fetch?: typeof fetch;
+    clock?: WallClock;
+}
+/**
+ * Sends Web Push messages (RFC 8030), each encrypted to its subscription
+ * and signed with `keys` as the server they subscribed to.
+ */
+export declare class WebPusher implements Pusher {
+    private readonly keys;
+    private readonly subject;
+    private readonly fetcher;
+    private readonly clock;
+    /** `subject` is a `mailto:` or `https:` URL a push service can reach the sender at. */
+    constructor(keys: VapidKeys, subject: string, opts?: WebPusherOptions);
+    push(subscription: Subscription, payload: string, opts?: PushOptions): Promise<void>;
+}

package/vendor/core/ship/artifact/artifact.d.ts

@@ -0,0 +1,52 @@
+import type { Logger } from "../../log/index.js";
+import type { Cut } from "../cut";
+import type { Step } from "../step";
+/** Use a stage to place an artifact before or after the other release work. */
+export type Stage = "stamp" | "build" | "publish" | "approve" | "tag" | "notes";
+/** Every stage, in the order a release runs them. */
+export declare const STAGES: readonly Stage[];
+/** Implement an artifact to add a publishing operation to `releases.lockstep`. */
+export interface Artifact {
+    /** What `Release.status()` calls it; its packages or its stage when omitted. */
+    readonly name?: string;
+    /** The public workspace packages this artifact publishes, if any. */
+    readonly packages: readonly string[];
+    /** When this runs relative to the other artifacts; `publish` when omitted. */
+    readonly stage?: Stage;
+    /** Carries this artifact out at the version in `cut`. */
+    publish(cut: Cut): Promise<void>;
+    /**
+     * What `publish` does in a dry run, as `Step.dryRun`; an artifact with
+     * `steps` gives each step its own instead.
+     */
+    dryRun?(cut: Cut): Promise<void>;
+    /**
+     * Declares finer-grained progress and resume steps. Without it, the release
+     * wraps `publish` in one step.
+     */
+    steps?(cut: Cut): readonly Step[];
+    /**
+     * This artifact as `Release.publish()` runs it, from a CI job the registry
+     * trusts. Leave it off when it goes out the same way anywhere.
+     */
+    trusted?(): Artifact;
+    /**
+     * Has wherever this publishes trust the CI job `Release.publish()` runs in.
+     * Leave it off when nothing about it publishes from CI.
+     */
+    trust?(log: Logger): Promise<void>;
+    /**
+     * Throws, saying what to fix, when this artifact cannot go out as the
+     * checkout stands. The release asks before it stamps anything, so a
+     * mistake costs no version. Leave it off when there is nothing to check.
+     */
+    verify?(cut: Cut): Promise<void>;
+    /** Removes output this artifact created, after success or failure. */
+    clean?(cut: Cut): Promise<void>;
+    /**
+     * The version live wherever this artifact publishes to, or `undefined` when
+     * nothing is out yet. Leave it off when there is nowhere to ask, as for a
+     * build or a stamp, and `Release.status()` skips the artifact.
+     */
+    deployed?(): Promise<string | undefined>;
+}

package/vendor/core/ship/bundle/bun-bundle.d.ts

@@ -0,0 +1,71 @@
+import { type Fs, type Glob, type Ps } from "../../system/index.js";
+import type { Bundle } from "./bundle";
+/** What a `BunBundle` builds through; the real system by default. */
+export interface BunBundleOptions {
+    fs?: Fs;
+    ps?: Ps;
+    glob?: Glob;
+}
+/**
+ * Builds a package into `dist/`: one bundle per entry point, the declarations
+ * beside them, and a manifest of its own, so that directory is a whole package
+ * and the one thing a release sends. What goes out is JavaScript, so a consumer
+ * needs neither Bun nor a bundler nor a compiler pass over somebody else's
+ * source, and the source never leaves the repository.
+ *
+ * A package needing something made before it compiles says so with a `build`
+ * script in its manifest, and that runs first: `arbor` builds the page it
+ * serves, which its own source then imports. The compiler still runs after,
+ * because what a package makes for itself is its business and what it publishes
+ * as is the release's.
+ *
+ * A package that reads files of its own at runtime lists them in its
+ * manifest's `files`, as globs from its root, and they are copied into `dist`
+ * where they sit in the source. The build inlines what is imported, but a file
+ * read off disk is invisible to it, and would otherwise be missing only once
+ * published.
+ */
+export declare class BunBundle implements Bundle {
+    private readonly fs;
+    private readonly ps;
+    private readonly glob;
+    constructor(opts?: BunBundleOptions);
+    build(dir: string): Promise<string>;
+    /**
+     * What the published manifest's `workspace:` and `catalog:` ranges resolve
+     * against: each sibling's own version and the root catalog, read only for a
+     * package that has such a range.
+     */
+    private resolving;
+    clean(dir: string): Promise<void>;
+    /** Copies every file a `files` glob matches into the same place in `dist`. */
+    private copy;
+    /**
+     * The JavaScript and the declarations for every entry point a package has,
+     * written to `outdir`, which is relative to `dir` unless it is absolute.
+     */
+    compile(dir: string, entries: string[], outdir?: string): Promise<void>;
+    /**
+     * The declaration files a package keeps at its root, which say what its
+     * non-code imports are. Nothing loads the workspace tsconfig during a build,
+     * so anything ambient has to be handed over by name or tsc will not believe
+     * in it: `rules` imports each rule's markdown, and `md.d.ts` is what says
+     * markdown is a string.
+     */
+    private ambient;
+    /**
+     * Points every relative specifier in the emitted declarations at a `.js`
+     * file. tsc writes them bare, which a consumer resolving as node16 rejects
+     * outright, and which with `skipLibCheck` on it does not report at all: the
+     * references quietly fail and every export becomes `any`, so the types are
+     * lost without anybody being told. A `.js` specifier resolves to the
+     * declaration beside it under both node16 and bundler resolution, so the one
+     * output serves either.
+     *
+     * This runs over whatever is in `dist`, however it got there, so a package
+     * building itself does not have to remember. A specifier that already names
+     * a file is left alone, which is what makes running it twice harmless.
+     */
+    private point;
+    private run;
+}

package/vendor/core/ship/bundle/bundle-artifact.d.ts

@@ -0,0 +1,21 @@
+import type { Artifact, Stage } from "../artifact/artifact";
+import type { Cut } from "../cut";
+import type { Bundle } from "./bundle";
+/**
+ * Builds every package that is going out, before any of them do. Its stage is
+ * what makes that true: a build that fails once a registry has taken half the
+ * workspace leaves versions nobody can install and nobody can republish, so
+ * the compiler runs while failing is still free.
+ *
+ * It publishes no packages of its own, so it does not appear in what a release
+ * says it will send.
+ */
+export declare class BundleArtifact implements Artifact {
+    private readonly bundle;
+    readonly packages: readonly string[];
+    readonly stage: Stage;
+    constructor(bundle?: Bundle);
+    publish(cut: Cut): Promise<void>;
+    /** Built output is the release's, not the repository's, however it ended. */
+    clean(cut: Cut): Promise<void>;
+}

package/vendor/core/ship/bundle/bundle.d.ts

@@ -0,0 +1,13 @@
+/** Turning a package's source into the files that actually go out. */
+export interface Bundle {
+    /**
+     * Builds the package in `dir` and answers where the result publishes from,
+     * which is a directory of its own rather than `dir` itself: a package
+     * publishes what it built, and nothing publishes what it was written in.
+     * Throws if it does not build, which is the whole point of running before
+     * anything reaches a registry.
+     */
+    build(dir: string): Promise<string>;
+    /** Removes what `build` left, whether or not it got that far. */
+    clean(dir: string): Promise<void>;
+}

package/vendor/core/ship/bundle/published.d.ts

@@ -0,0 +1,45 @@
+/** A manifest, as far as anything here reads it. */
+export interface Manifest {
+    name?: string;
+    version?: string;
+    main?: string;
+    module?: string;
+    types?: string;
+    bin?: string | Record<string, string>;
+    exports?: Exports;
+    scripts?: Record<string, string>;
+    files?: string[];
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    [field: string]: unknown;
+}
+/** What a manifest's `exports` can hold, down to the paths a release rewrites. */
+export type Exports = string | {
+    [key: string]: Exports;
+};
+/**
+ * The manifest a package publishes, made from the one it is developed under.
+ *
+ * The two differ because they describe different trees. In the repository a
+ * package is its source, so its entry points name `.ts` files and its siblings
+ * are `workspace:` ranges. What goes out is the build, published from `dist`
+ * with that directory as its root, so the same entry points name the `.js` and
+ * `.d.ts` beside them and the siblings name the version they go out at, and
+ * a `catalog:` range names what the catalog gives.
+ *
+ * Generating it is what keeps the source out of the tarball: nothing has to be
+ * described twice, and the manifest a developer reads never has to pretend it
+ * is describing a package that has been built.
+ */
+export declare function published(manifest: Manifest, opts?: PublishedOptions): Manifest;
+/** What a published manifest's dependency ranges are resolved against. */
+export interface PublishedOptions {
+    /**
+     * Each workspace sibling's own version, by name: a sibling of another
+     * project goes out at its version, not this one's. A sibling missing here
+     * takes the version going out.
+     */
+    versions?: Readonly<Record<string, string>>;
+    /** The workspace's catalog, which every `catalog:` range is read from. */
+    catalog?: Readonly<Record<string, string>>;
+}

package/vendor/core/ship/bundle/reach.d.ts

@@ -0,0 +1,43 @@
+import type { Fs } from "../../system/index.js";
+import type { Exports, Manifest } from "./published";
+/**
+ * Every module specifier a file names, whether imported, re-exported, loaded
+ * with `import()` or written in a declaration. Both the compiler and tsc write
+ * double quotes, so source and output read the same way.
+ */
+export declare const SPECIFIER: RegExp;
+/** A source file a relative specifier can land on. */
+export declare const SOURCE: RegExp;
+/** A workspace package a release walks into, by name and where it sits. */
+export interface Reached {
+    name: string;
+    dir: string;
+}
+/** What `reach` found: the entry points and every source file they lead to. */
+export interface Reach {
+    /** The `exports` keys needed, such as `.` or `./time`. */
+    keys: Set<string>;
+    /** The package's own source files, tests left out. */
+    files: Set<string>;
+}
+/** The `exports` key a specifier of `pkg` names, which must be one it exports. */
+export declare function keyOf(pkg: {
+    name: string;
+}, exported: ReadonlyMap<string, string>, specifier: string): string;
+/**
+ * The entry points `keys` need, themselves included, with the package's own
+ * source followed through relative imports and through the entry points it
+ * names by its own name, as the platform test walks it.
+ */
+export declare function reach(fs: Fs, pkg: Reached, keys: readonly string[]): Promise<Reach>;
+/** Whether `specifier` names `name` or one of its subpaths. */
+export declare function isPackage(specifier: string, name: string): boolean;
+/** The package a specifier reaches outside the workspace and the runtime, if it does. */
+export declare function outsider(specifier: string): string | undefined;
+/** Every specifier in a file, in order. */
+export declare function specifiers(path: string, fs: Fs): Promise<string[]>;
+/** Each `exports` subpath beside the source file it resolves to, conditions looked through. */
+export declare function entries(exports: Exports): Map<string, string>;
+export declare function manifestAt(fs: Fs, dir: string): Promise<Manifest>;
+/** The root manifest's catalog, whichever way its workspaces are written. */
+export declare function catalogAt(fs: Fs, root: string): Promise<Record<string, string>>;

package/vendor/core/ship/bundle/vendor-bundle.d.ts

@@ -0,0 +1,47 @@
+import { type Fs, type Ps } from "../../system/index.js";
+import type { Workspace } from "../workspace/workspace";
+import { BunBundle } from "./bun-bundle";
+import type { Bundle } from "./bundle";
+/** What a `VendorBundle` builds and reads through; the real system by default. */
+export interface VendorBundleOptions {
+    /** Builds the package itself before its vendored code is added; a `BunBundle` by default. */
+    bundle?: BunBundle;
+    /** Where the private packages are found; the manifest workspace around the package by default. */
+    workspace?: Workspace;
+    /** Packages that must not be copied into a published one; scry and its rules by default. */
+    never?: readonly string[];
+    fs?: Fs;
+    ps?: Ps;
+}
+/**
+ * Builds a package the way `BunBundle` does, then folds in the private
+ * workspace packages it depends on, so that what goes out installs and runs
+ * with none of them on a registry.
+ *
+ * A dependency is vendored when it is a `workspace:` range on a private
+ * package, which is the only kind a registry cannot have. Only the entry
+ * points the package reaches are copied, with whatever those reach in turn,
+ * into `dist/vendor/<name>`, and every import of the package is rewritten to
+ * the copy beside it. What the copy needs from outside the workspace joins the
+ * published manifest under the range the vendored package declared, optional
+ * peers staying optional peers: they are never bundled.
+ */
+export declare class VendorBundle implements Bundle {
+    private readonly opts;
+    private readonly fs;
+    private readonly ps;
+    private readonly bundle;
+    constructor(opts?: VendorBundleOptions);
+    build(dir: string): Promise<string>;
+    clean(dir: string): Promise<void>;
+    private vendor;
+    /** Every JavaScript and declaration file the build left, vendored copies included. */
+    private built;
+    /**
+     * Adds what the vendored copy imports from outside the workspace to the
+     * manifest going out, under the range its own manifest gave, with `catalog:`
+     * read through the workspace's catalog. A peer stays a peer, and stays
+     * optional when it was.
+     */
+    private declare;
+}

package/vendor/core/ship/cut.d.ts

@@ -0,0 +1,64 @@
+import { type Logger } from "../log/index.js";
+import type { Package } from "./workspace/workspace";
+/**
+ * Where a dry run keeps what it makes in place of sending it: the packages it
+ * packs in `<dir>/packs`, the copies of remotes it pushes to in
+ * `<dir>/remotes`, and the project that installs the packs in
+ * `<dir>/consumer`. Several releases sharing one see each other's packs.
+ */
+export interface DryRun {
+    dir: string;
+}
+/** Where a `Cut` speaks and sits; the console and the working directory by default. */
+export interface CutOptions {
+    /** Set for a dry run, which sends nothing out. */
+    dryRun?: DryRun;
+    log?: Logger;
+    /** The workspace root, which any path an artifact holds is relative to. */
+    root?: string;
+}
+/**
+ * The release under way, as one artifact of it sees it: the version everything
+ * goes out at, the tag that names it, and where the packages sit. By the time
+ * an artifact is handed one, every package is stamped; everything past the
+ * `stamp` stage sees that stamp committed too.
+ */
+export declare class Cut {
+    /** The version every package in this release goes out at. */
+    readonly version: string;
+    /**
+     * Every package in the workspace, each one after the siblings it depends
+     * on. An artifact that works through them in this order never reaches a
+     * package before whatever it needs is ready.
+     */
+    readonly packages: readonly Package[];
+    /** The tag naming this release, such as `v1.2.4`. */
+    readonly tag: string;
+    /** Where an artifact says what it did. */
+    readonly log: Logger;
+    /** The workspace root, which any path an artifact holds is relative to. */
+    readonly root: string;
+    /** Set for a dry run, which sends nothing out. */
+    readonly dryRun?: DryRun;
+    /** Package name to where a build put what that package publishes. */
+    private readonly staged;
+    constructor(
+    /** The version every package in this release goes out at. */
+    version: string, 
+    /**
+     * Every package in the workspace, each one after the siblings it depends
+     * on. An artifact that works through them in this order never reaches a
+     * package before whatever it needs is ready.
+     */
+    packages: readonly Package[], opts?: CutOptions);
+    /**
+     * Where the named package publishes from, when the workspace has it: what a
+     * build staged for it, or its own directory when nothing built anything.
+     */
+    dir(name: string): string | undefined;
+    /**
+     * Says the named package publishes from `dir`. A build calls this so that
+     * the stage after it sends the built package rather than the source one.
+     */
+    stage(name: string, dir: string): void;
+}

package/vendor/core/ship/dry-run.d.ts

@@ -0,0 +1,63 @@
+import type { Fs, Ps } from "../system/index.js";
+import { type Artifact } from "./artifact/artifact";
+import type { Manifest } from "./bundle/published";
+import type { Cut } from "./cut";
+import type { Git } from "./git/git";
+import type { Step } from "./step";
+import type { StepDeclaration } from "./step-events";
+import type { StepRunner } from "./step-runner";
+/** A release's declared steps and what a dry run of them runs through. */
+export interface RehearsalOptions {
+    preflight: StepDeclaration;
+    before: readonly StepDeclaration[];
+    versionStep: StepDeclaration;
+    going: readonly StepDeclaration[];
+    artifacts: readonly Artifact[];
+    /** The packages the release publishes. */
+    packages: readonly string[];
+    cut: Cut;
+    runner: StepRunner;
+    git: Git;
+    fs: Fs;
+    ps: Ps;
+    /** Whether the dry run's directory is the run's own, to remove after. */
+    owned: boolean;
+}
+/**
+ * Runs a release's steps as a dry run takes them: each with a `dryRun` runs
+ * that, one without runs as usual up to the build and is skipped after, and
+ * the packs are installed right after they would have been published.
+ * Whatever happens, the stamp is undone, the build cleaned and a directory
+ * the run made for itself removed.
+ */
+export declare function rehearse(opts: RehearsalOptions): Promise<void>;
+/** What `installStep` installs and imports through. */
+export interface InstallStepOptions {
+    /** The packages the release publishes, whose exports are imported. */
+    packages: readonly string[];
+    fs: Fs;
+    ps: Ps;
+}
+/**
+ * The step a dry run adds after packing: installs every pack in the dry run's
+ * `packs` into a project of its own, outside the workspace, and imports each
+ * export of the release's packages with Node, or with Bun when one of them
+ * names Bun among its `engines`, so a dependency npm cannot
+ * resolve or an import the build left pointing into the workspace fails here
+ * rather than for the first person to install it. Packs another release left
+ * in the same dry run install too, so a package depending on one going out
+ * beside it gets that one.
+ */
+export declare function installStep(opts: InstallStepOptions): Step;
+/**
+ * Every specifier a consumer can import from `name`, as its manifest exports
+ * them, but for a `testing` subpath: test helpers load only under a test
+ * runner, whose hooks they register as they are imported.
+ */
+export declare function importable(name: string, manifest: Manifest): string[];
+/**
+ * `declaration` as a dry run runs it: its own `dryRun` with no check after,
+ * as declared up to the build, and skipped from the publish stage on when it
+ * has no `dryRun`, so nothing goes out that nobody said could go out.
+ */
+export declare function rehearsed(declaration: StepDeclaration): StepDeclaration;

package/vendor/core/ship/git/cli-git.d.ts

@@ -0,0 +1,25 @@
+import { type Ps } from "../../system/index.js";
+import type { Git } from "./git";
+/** What a `CliGit` spawns through; the real process by default. */
+export interface CliGitOptions {
+    ps?: Ps;
+}
+/** Speaks git by spawning the CLI. */
+export declare class CliGit implements Git {
+    private readonly root;
+    private readonly ps;
+    constructor(root: string, opts?: CliGitOptions);
+    clean(): Promise<boolean>;
+    branch(): Promise<string>;
+    head(): Promise<string>;
+    /** Where releases go out from. */
+    defaultBranch(): Promise<string>;
+    /** Commits every tracked change. A clean tree is already committed, so it passes. */
+    discard(): Promise<void>;
+    commitAll(message: string): Promise<void>;
+    tag(tag: string): Promise<void>;
+    push(ref: string): Promise<void>;
+    remoteTags(pattern: string): Promise<string[]>;
+    private run;
+    private out;
+}

package/vendor/core/ship/git/git-artifact.d.ts

@@ -0,0 +1,23 @@
+import { type Ps } from "../../system/index.js";
+import type { Artifact, Stage } from "../artifact/artifact";
+import type { Cut } from "../cut";
+import type { Step } from "../step";
+import type { Git } from "./git";
+/** What a `GitArtifact` speaks git through; the repository here by default. */
+export interface GitArtifactOptions {
+    git?: Git;
+    ps?: Ps;
+}
+/** Pushes the release commit and tag after every package has published. */
+export declare class GitArtifact implements Artifact {
+    readonly name = "git tag";
+    readonly packages: readonly string[];
+    readonly stage: Stage;
+    private readonly git;
+    constructor(opts?: GitArtifactOptions);
+    steps(cut: Cut): readonly Step[];
+    publish(cut: Cut): Promise<void>;
+    /** The version of the newest release tag on origin. */
+    deployed(): Promise<string | undefined>;
+    private pushBranch;
+}

package/vendor/core/ship/git/git.d.ts

@@ -0,0 +1,19 @@
+/** The git a release speaks, scoped to one repository. */
+export interface Git {
+    /** Whether the tree has no uncommitted changes. */
+    clean(): Promise<boolean>;
+    branch(): Promise<string>;
+    /** The commit HEAD is at. */
+    head(): Promise<string>;
+    /** Where releases go out from. */
+    defaultBranch(): Promise<string>;
+    /** Puts every tracked file back as HEAD has it, as a dry run does with its stamp. */
+    discard(): Promise<void>;
+    /** Commits every tracked change. A clean tree is already committed, so it passes. */
+    commitAll(message: string): Promise<void>;
+    /** Tags the commit at HEAD. A tag already there is left where it is. */
+    tag(tag: string): Promise<void>;
+    push(ref: string): Promise<void>;
+    /** The names of origin's tags matching `pattern`, a glob such as `v*`. */
+    remoteTags(pattern: string): Promise<string[]>;
+}

package/vendor/core/ship/github/cli-github.d.ts

@@ -0,0 +1,31 @@
+import { type Ps } from "../../system/index.js";
+import type { Github } from "./github";
+/** GitHub releases, via the `gh` CLI. */
+/** What a `CliGithub` spawns through; the real process by default. */
+export interface CliGithubOptions {
+    /**
+     * The repository the releases are on, as `owner/name`, such as a project's
+     * public mirror; the one `gh` finds from the working directory by default.
+     */
+    repo?: string;
+    ps?: Ps;
+}
+export declare class CliGithub implements Github {
+    private readonly ps;
+    /** `--repo <repo>` when a repository is named, so gh skips its own lookup. */
+    private readonly on;
+    constructor(opts?: CliGithubOptions);
+    /** Where the releases are, for a log line. */
+    get repo(): string | undefined;
+    /**
+     * Publishes release notes for `tag`, or leaves the existing ones alone,
+     * asking for a login first if gh has nobody.
+     */
+    release(tag: string): Promise<void>;
+    /**
+     * The tag of the release GitHub marks latest. Reading asks for no login,
+     * since a status check is no time to stop for a browser.
+     */
+    latest(): Promise<string | undefined>;
+    private login;
+}

package/vendor/core/ship/github/cli-workflows.d.ts

@@ -0,0 +1,25 @@
+import { type Ps } from "../../system/index.js";
+import type { WorkflowRun, Workflows } from "./workflows";
+/** What a `CliWorkflows` spawns through; the real process by default. */
+export interface CliWorkflowsOptions {
+    /**
+     * The repository the workflows run in, as `owner/name`; the one the working
+     * directory checks out by default.
+     */
+    repo?: string;
+    ps?: Ps;
+}
+/** GitHub Actions workflows, via the `gh` CLI. */
+export declare class CliWorkflows implements Workflows {
+    private readonly ps;
+    private readonly named?;
+    constructor(opts?: CliWorkflowsOptions);
+    repo(): Promise<string>;
+    registered(file: string): Promise<boolean>;
+    dispatch(file: string, branch: string, inputs: Record<string, string>): Promise<void>;
+    runs(file: string, sha: string): Promise<WorkflowRun[]>;
+    rerun(id: string, failedOnly: boolean): Promise<void>;
+    failedLog(id: string): Promise<string>;
+    /** Runs gh, logging in first when `login` says to; throws on a nonzero exit. */
+    private gh;
+}

package/vendor/core/ship/github/github-artifact.d.ts

@@ -0,0 +1,18 @@
+import type { Artifact, Stage } from "../artifact/artifact";
+import type { Cut } from "../cut";
+import type { Github } from "./github";
+/**
+ * The GitHub release notes for the tag. Its stage puts it after the tag,
+ * which is what it writes about.
+ */
+export declare class GithubArtifact implements Artifact {
+    private readonly github;
+    readonly name = "GitHub release";
+    readonly packages: readonly string[];
+    readonly stage: Stage;
+    constructor(github: Github);
+    publish(cut: Cut): Promise<void>;
+    dryRun(cut: Cut): Promise<void>;
+    /** The version of the release GitHub marks latest. */
+    deployed(): Promise<string | undefined>;
+}

package/vendor/core/ship/github/github.d.ts

@@ -0,0 +1,10 @@
+/** The GitHub releases a release publishes. */
+export interface Github {
+    /**
+     * Publishes release notes for `tag`, or leaves the existing ones alone,
+     * logging in along the way if that is what it takes.
+     */
+    release(tag: string): Promise<void>;
+    /** The tag of the latest release, or `undefined` when there is none. */
+    latest(): Promise<string | undefined>;
+}

package/vendor/core/ship/github/login.d.ts

@@ -0,0 +1,3 @@
+import type { Ps } from "../../system/index.js";
+/** Runs `gh auth login` unless somebody is already logged in. GH_TOKEN counts. */
+export declare function ghLogin(ps: Ps): Promise<void>;