@stringsync/splates 0.0.60 → 1.13.3

package/vendor/core/ship/mirror/agent-files.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Left out of every mirror: what only helps agents work in mono, since a mirror
+ * holds the bare minimum to run. Globs match paths relative to the mirrored
+ * project's folder.
+ */
+export declare const AGENT_FILES: string[];

package/vendor/core/ship/mirror/mirror-build.d.ts

@@ -0,0 +1,63 @@
+import type { Artifact, Stage } from "../artifact/artifact";
+import type { Bundle } from "../bundle/bundle";
+import type { Cut } from "../cut";
+import type { GithubActions } from "../registry/github-actions";
+import type { Step } from "../step";
+import type { MirrorOptions } from "./mirror-options";
+/** What `MirrorBuild` mirrors, and how it builds the packages there. */
+export interface MirrorBuildOptions extends MirrorOptions {
+    /**
+     * Builds each package in the mirror; a `VendorBundle` by default, which
+     * folds in the mirror's own copy of `core`.
+     */
+    bundle?: Bundle;
+    /**
+     * Publishes through GitHub Actions in the mirror's repository: the same
+     * `GithubActions` given to each `releases.npm` as `via`, made with the
+     * mirror's `repo`. Its run starts from the mirror's commit, which carries
+     * the publish workflow; give `publish` too.
+     */
+    via?: GithubActions;
+    /**
+     * The command the mirror's publish workflow runs, from the mirror's root,
+     * to build and publish at the version the commit stands at, such as
+     * `bin/mdom publish`, which calls `Release.publish()`. The workflow is
+     * written into the mirror commit.
+     */
+    publish?: string;
+}
+/**
+ * Builds what a release publishes from its public repository rather than the
+ * workspace: in the build stage it writes the mirror's commit to a checkout
+ * of the remote, installs it as anyone cloning it would, from the registry,
+ * and builds each of the project's public packages there, so what goes out
+ * is what the public repository builds. A package of another project is
+ * installed at its published release, so one that needs a change not yet
+ * released fails here. The tag stage pushes that same commit, and its tag.
+ *
+ * Use it in place of `build`, `vendor` and `mirror`, not beside them.
+ */
+export declare class MirrorBuild implements Artifact {
+    private readonly opts;
+    readonly packages: readonly string[];
+    readonly stage: Stage;
+    readonly name: string;
+    private readonly fs;
+    private readonly ps;
+    private readonly mirror;
+    private readonly bundle;
+    /** The mirror the build made and the step that pushes it, once built. */
+    private built?;
+    constructor(opts: MirrorBuildOptions);
+    steps(): readonly Step[];
+    publish(cut: Cut): Promise<void>;
+    clean(): Promise<void>;
+    /**
+     * Writes the mirror, installs it and commits it with the lockfile that
+     * install wrote, which is what its publish workflow installs from, then
+     * builds the packages there.
+     */
+    private build;
+    private push;
+    private spawn;
+}

package/vendor/core/ship/mirror/mirror-guard.d.ts

@@ -0,0 +1,10 @@
+import type { Ps } from "../../system/index.js";
+/** The trailer of a mirror commit naming the mono commit it was built from. */
+export declare const TRAILER = "Mirrored-from";
+/**
+ * Refuses to build over commits the mirror did not make. The mirror rebuilds
+ * the whole tree from mono, so a commit made on the remote since the last
+ * mirror commit (found by its trailer, or its subject before the trailer existed; or since `adopt`, for a repository with history of its own)
+ * would be reverted without a word. Run in a checkout of the branch.
+ */
+export declare function guard(ps: Ps, mirror: string, project: string, adopt: string | undefined): Promise<void>;

package/vendor/core/ship/mirror/mirror-options.d.ts

@@ -0,0 +1,75 @@
+import type { Fs, Glob, Ps } from "../../system/index.js";
+import type { Workspace } from "../workspace/workspace";
+/** The caller's rules for what a mirror holds. */
+export interface MirrorConfig {
+    /**
+     * Globs matched against paths relative to the workspace root, such as
+     * `**\/.vet/**`, applied to everything copied: the project's own files and
+     * the vendored source. What never leaves the repository (`node_modules`,
+     * `dist`, `.git`) is left out whatever these say.
+     */
+    exclude?: readonly string[];
+    /**
+     * Globs matched against paths relative to the project folder, such as
+     * `skills/splates/**`, for what the mirror keeps though it would otherwise
+     * leave it out as an agent file (`AGENTS.md`, `skills/**` and the like), for
+     * a project whose skill is the product. `exclude` still applies to them.
+     */
+    keep?: readonly string[];
+    /**
+     * Files that stand in for others in the mirror, by path relative to the
+     * project folder: each key is the path the mirror holds the file at, each
+     * value the project file it is read from, which the mirror does not hold
+     * under its own name. For a `Dockerfile` that only fits the mirror's layout.
+     */
+    replace?: Readonly<Record<string, string>>;
+    /**
+     * Edits to a file's text in the mirror, by path relative to the project
+     * folder (the mirror's path for it): each rule is a `[pattern, with]` pair,
+     * applied in order to the whole text as `String.replace` does, so a pattern
+     * with the `g` flag rewrites every match and `with` can use `$1`. This lets
+     * one file, such as a `Dockerfile`, serve both layouts: strip a folder prefix,
+     * move a path, or drop a line by matching it whole and replacing it with `""`.
+     * A rule that matches nothing is refused, so a stale one cannot go unnoticed.
+     */
+    rewrite?: Readonly<Record<string, readonly (readonly [RegExp, string])[]>>;
+    /**
+     * Scripts for the mirror's root manifest, such as a `postinstall` that
+     * builds what the project's tests import, which the workspace root's own
+     * scripts do in the workspace and the mirror does not carry.
+     */
+    scripts?: Readonly<Record<string, string>>;
+}
+/** What a `MirrorStep` copies, and where it pushes; the real system by default. */
+export interface MirrorOptions {
+    /**
+     * The folder mirrored, relative to the workspace root: a project's
+     * top-level folder, such as `mdom`, or one package's, such as
+     * `sound2score/packages/player`, which then stands at the mirror's root.
+     */
+    project: string;
+    /** The public repository the project is mirrored to, as `git clone` takes it. */
+    remote: string;
+    /** The branch pushed to; `main` by default. */
+    branch?: string;
+    /**
+     * The commit of the remote branch the first mirror takes over from, for a
+     * repository with history of its own. Without a mirror commit on the branch
+     * (`Mirror <project> at <tag>`), commits after it are refused; once there is
+     * one, it decides and this no longer matters.
+     */
+    adopt?: string;
+    /** Tags the mirror's commit with the release's tag and pushes it too. */
+    tag?: boolean;
+    /** What the mirror leaves out and how; nothing is excluded by default. */
+    config?: MirrorConfig;
+    /** The workspace package folded in as source; `core` by default. */
+    source?: string;
+    /** Where the mirror is checked out while it is built; a temporary directory by default. */
+    scratch?: string;
+    /** Where the workspace is found; the manifest workspace around the working directory by default. */
+    workspace?: Workspace;
+    fs?: Fs;
+    ps?: Ps;
+    glob?: Glob;
+}

package/vendor/core/ship/mirror/mirror-step.d.ts

@@ -0,0 +1,109 @@
+import { Duration } from "../../time/index.js";
+import type { Cut } from "../cut";
+import type { Step } from "../step";
+import type { MirrorOptions } from "./mirror-options";
+export type { MirrorConfig, MirrorOptions } from "./mirror-options";
+/** What `MirrorStep.prepare` does besides writing the tree. */
+export interface PrepareOptions {
+    /**
+     * Runs once the tree is written and before it is committed, so whatever
+     * it adds is part of the mirror commit: a lockfile an install writes.
+     */
+    before?(mirror: string): Promise<void>;
+}
+/** The mirror commit `MirrorStep.prepare` made, ready to push. */
+export interface PreparedMirror {
+    /** The mirror's checkout. */
+    dir: string;
+    /** The project folder it was written from, which its root stands for. */
+    from: string;
+    /** Whether the tree changed, and so whether there is a commit to push. */
+    changed: boolean;
+}
+/**
+ * Makes a project's public repository stand alone from the workspace: copies
+ * the project folder to the root of a checkout of `remote`, adds the source of
+ * the workspace package it reaches (`core`) as a private workspace package of
+ * its own, and pushes the result when the tree changed.
+ *
+ * Imports are left as they are. The project keeps `"core": "workspace:*"` and
+ * keeps importing `core/...`; in the mirror that resolves to the copied
+ * package, which carries only the `exports` the project reaches and the
+ * dependencies those need, from the versions the workspace's catalog gives.
+ * Files matching the config's `exclude` globs, matched against paths relative
+ * to the workspace root, are left out of everything copied.
+ */
+export declare class MirrorStep implements Step {
+    private readonly opts;
+    readonly name: string;
+    readonly deadline: Duration;
+    readonly stage: "tag";
+    private readonly fs;
+    private readonly ps;
+    private readonly glob;
+    private readonly tooling;
+    constructor(opts: MirrorOptions);
+    run(cut: Cut): Promise<void>;
+    /** Where the mirror is checked out while it is built. */
+    get scratch(): string;
+    /**
+     * Checks out the remote into `scratch`, writes the mirror's tree over it and
+     * commits it there, pushing nothing; `push` sends what this left. The
+     * checkout stays for the caller to install, build or remove.
+     */
+    prepare(cut: Cut, opts?: PrepareOptions): Promise<PreparedMirror>;
+    /** Pushes the commit `prepare` made, and its tag when the mirror is tagged. */
+    push(cut: Cut, prepared: PreparedMirror): Promise<void>;
+    /**
+     * Mirrors as `run` would, onto a copy of the remote instead of the remote:
+     * the guard and the push meet its real history, and nothing reaches it.
+     */
+    dryRun(cut: Cut): Promise<void>;
+    /**
+     * Use this mirror's rehearsal in a dry run in place of the mirror: it runs,
+     * prepares and pushes as this one does, and nothing it does reaches the
+     * remote.
+     */
+    rehearsal(cut: Cut): Promise<MirrorStep>;
+    /**
+     * Writes the whole mirror tree into `mirror`, which is empty but for
+     * `.git`; the workspace root it read from.
+     */
+    private build;
+    /**
+     * Refuses a package that needs what the mirror cannot hold. A public
+     * package of another project is no obstacle: the mirror depends on its
+     * published build instead, and its name is returned.
+     */
+    private checkDependencies;
+    /** Puts each `config.replace` file at the path it stands in for. */
+    private replace;
+    /** Applies each `config.rewrite` rule to the file it names. */
+    private rewrite;
+    /**
+     * Points each dependency on a published workspace package at its release
+     * (`^version`, the version that package stands at), in the mirror's copy
+     * of the manifests, since the mirror holds no such package.
+     */
+    private publish;
+    /** The `core` entry points the copied source names, and the files they lead to. */
+    private reached;
+    /**
+     * What the mirror's root holds that no project folder does: the manifest
+     * naming the workspaces and the catalog entries used, the base tsconfig,
+     * the toolchain the root pins, the lint config and a gitignore.
+     */
+    private rootFiles;
+    /** Every file under `dir`, dotfiles included. */
+    private files;
+    /** Copies `from` to `to` but for what `skip` names, by path relative to `from`; the paths written. */
+    private copy;
+    private copyFile;
+    private write;
+    private excluded;
+    /** Whether the remote has `tag`. */
+    private tagged;
+    /** Checks out `branch`, from the remote's when it has one and as a new branch when not. */
+    private checkout;
+    private git;
+}

package/vendor/core/ship/mirror/mirror-tooling.d.ts

@@ -0,0 +1,59 @@
+import type { Fs, Ps } from "../../system/index.js";
+/** What `MirrorTooling` writes for, and the system it writes with. */
+export interface MirrorToolingOptions {
+    /** The folder mirrored, which a refusal names. */
+    project: string;
+    fs: Fs;
+    ps: Ps;
+}
+/**
+ * The tool configs at a mirror's root: the workspace root's, with the
+ * mirrored folder's own laid over them, since the mirror has no root above it
+ * to inherit them from.
+ */
+export declare class MirrorTooling {
+    private readonly opts;
+    constructor(opts: MirrorToolingOptions);
+    private get fs();
+    private get ps();
+    /**
+     * Points each tsconfig of `files` that extends the workspace's base at the mirror's
+     * copy of it, at the mirror's root, from wherever the mirror holds it.
+     */
+    tsconfigs(dir: string, files: readonly string[]): Promise<void>;
+    /**
+     * The root's `.gitignore` with its patterns rooted in the mirror, then the
+     * project's own: a path under the mirrored folder loses that prefix and one
+     * under any other folder is dropped. What the workspace ignores, such as a
+     * build's output an install writes, stays out of the mirror commit and out
+     * of a clone's tree.
+     */
+    gitignore(root: string, mirror: string): Promise<void>;
+    /** A root `.gitignore` line as the mirror holds it, or nothing for another folder's path. */
+    private rooted;
+    /**
+     * The root's `bunfig.toml` with the project's own after it, so a project's
+     * test preload survives beside the root's install settings. Two files that
+     * set the same table cannot be joined, and are refused.
+     */
+    bunfig(root: string, mirror: string): Promise<void>;
+    /**
+     * The lint config: the root's, with the project's own overrides laid over
+     * it. The copied source is left out of it, since the project's style (its
+     * quotes, say) is not the one that source is written and checked in.
+     */
+    lint(root: string, mirror: string, source: string): Promise<void>;
+    /**
+     * The root's overrides as the mirror sees them: their paths run from the
+     * workspace root, so the mirrored folder's prefix is dropped, and an
+     * override left with no path in the mirror is dropped. Globs that start
+     * with a wildcard match anywhere and stay as they are.
+     */
+    private overrides;
+    /**
+     * Formats JSON the step wrote, by path relative to `mirror`, with the
+     * root's biome and the mirror's own config, so the mirror passes its own
+     * check. Nothing is formatted where the root has no biome installed.
+     */
+    private format;
+}

package/vendor/core/ship/mirror/source-manifest.d.ts

@@ -0,0 +1,27 @@
+import type { Fs } from "../../system/index.js";
+import type { Manifest } from "../bundle/published";
+import type { Package } from "../workspace/workspace";
+/** A manifest as far as the mirror writes one. */
+export type Json = Manifest & {
+    peerDependenciesMeta?: Record<string, object>;
+    devDependencies?: Record<string, string>;
+};
+/** The manifest fields a mirror reads dependencies from. */
+export declare const FIELDS: readonly ["dependencies", "peerDependencies", "devDependencies"];
+/** What the source package's manifest in a mirror is cut down to. */
+export interface SourceManifestOptions {
+    /** The export keys the mirrored project reaches. */
+    keys: ReadonlySet<string>;
+    /** The source files the mirror copies. */
+    files: ReadonlySet<string>;
+    /** The workspace's catalog, which `catalog:` ranges are read from. */
+    catalog: Record<string, string>;
+    /** The version the release goes out at. */
+    version: string;
+}
+/**
+ * The mirrored source package's manifest: only the entry points reached, and
+ * the dependencies and optional peers those files import, at the ranges the
+ * package declared with `catalog:` read through the workspace's catalog.
+ */
+export declare function sourceManifest(fs: Fs, core: Package, { keys, files, catalog, version }: SourceManifestOptions): Promise<Json>;

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

@@ -0,0 +1,15 @@
+import type { Package } from "./workspace/workspace";
+/**
+ * `packages`, each one after everything it depends on. A release both builds
+ * and publishes in this order, for the same reason in both cases: a package
+ * cannot be built against a sibling whose `dist` is not there yet, and cannot
+ * be installed alongside a sibling the registry has never heard of. Ordering
+ * this way is what makes a release that dies partway leave a smaller release
+ * rather than a broken one.
+ *
+ * Everything able to go at once goes together in name order, so the same
+ * workspace always gives the same sequence and a failed release resumes into
+ * the one it left. Packages that depend on nothing stay near the front, where
+ * they read as the foundation they are.
+ */
+export declare function order(packages: readonly Package[]): Package[];

package/vendor/core/ship/publish-workflow.d.ts

@@ -0,0 +1,32 @@
+import { type Fs } from "../system/index.js";
+/**
+ * Where the stub lives. The name is fixed because npm's trusted publisher
+ * entry for each package names this file.
+ */
+export declare const PUBLISH_WORKFLOW_PATH = ".github/workflows/webappwiz-publish.yml";
+/** What a `PublishWorkflow` reads and writes through; the real filesystem by default. */
+export interface PublishWorkflowOptions {
+    /** The command the job runs to publish, such as `bunx @webappwiz/cli ship publish`. */
+    command: string;
+    fs?: Fs;
+}
+/**
+ * The GitHub Actions workflow that publishes a release from a job npm trusts.
+ * It is generated and holds no package list: it checks out the release commit
+ * and runs the declaration's own publish-only mode, so the `Release` stays the
+ * one place that says what ships. Commit it like a lockfile; a release writes
+ * it when it is missing or stale, and `check` fails on drift.
+ */
+export declare class PublishWorkflow {
+    private readonly command;
+    private readonly fs;
+    constructor(opts: PublishWorkflowOptions);
+    /** The workflow file's whole text. */
+    text(): string;
+    /** What is wrong with the file under `root`, or `undefined` when it is current. */
+    drift(root: string): Promise<"missing" | "stale" | undefined>;
+    /** Writes the file under `root` when it is missing or stale; whether it wrote. */
+    write(root: string): Promise<boolean>;
+    /** Throws when the file under `root` is missing or stale. */
+    check(root: string): Promise<void>;
+}

package/vendor/core/ship/registry/github-actions.d.ts

@@ -0,0 +1,76 @@
+import { type Ps } from "../../system/index.js";
+import { Duration } from "../../time/index.js";
+import type { Git } from "../git/git";
+import type { Workflows } from "../github/workflows";
+import type { CheckReport } from "../step";
+/** Pass `git` or `workflows` to run `GithubActions` against fakes in tests; the real ones by default. */
+export interface GithubActionsOptions {
+    git?: Git;
+    workflows?: Workflows;
+    ps?: Ps;
+    /**
+     * What a refused run says to run to set up npm's trust, which calls
+     * `Release.trust()`; `bunx @webappwiz/cli ship trust` by default.
+     */
+    trustCommand?: string;
+    /**
+     * The repository the workflow runs in, as `owner/name`; the one the
+     * working directory checks out by default. Set it with `use` for a
+     * workflow in a mirror's repository.
+     */
+    repo?: string;
+    /** What waits between asks while GitHub registers the workflow; real time by default. */
+    pause?: (duration: Duration) => Promise<void>;
+}
+/** Use it as `releases.npm`'s `via`: `githubActions()` makes one. */
+export declare function githubActions(opts?: GithubActionsOptions): GithubActions;
+/**
+ * Publishes by running the generated publish workflow on GitHub Actions, where
+ * npm trusts the job, rather than from this machine. It pushes the release
+ * commit, starts the workflow on it, and follows the run; whether a version
+ * went out is still the registry's to say, never the run's green check.
+ *
+ * A release has one run for all its packages, found again by its commit: a
+ * second package reuses it, and a resumed release reuses a run still going or
+ * finished, and reruns one that failed.
+ */
+export declare class GithubActions {
+    /** The workflow's file name, as npm's trusted publisher entry names it. */
+    readonly file: string;
+    private git;
+    private readonly workflows;
+    /** The attempt of the run a rerun started from, whose result is stale until a newer one shows. */
+    private rerunFrom?;
+    private readonly trustCommand;
+    private readonly pause;
+    constructor(opts?: GithubActionsOptions);
+    /**
+     * Has the run start from the checkout `git` works in, whose branch it
+     * pushes and whose commit it publishes: a mirror's, once it is built.
+     */
+    use(git: Git): void;
+    /** The repository the workflow runs in, as `owner/name`. */
+    repo(): Promise<string>;
+    /**
+     * Gets a run going for the release commit: pushes the branch so GitHub has
+     * the commit, then starts the workflow, reruns its failed run, or leaves
+     * the run it has alone. Returns once that is asked, not once it ends.
+     */
+    start(): Promise<void>;
+    /**
+     * Polls until GitHub lists the workflow as active. The push that first
+     * brings the workflow file to the default branch is not seen at once, and
+     * asking for its runs or dispatching it before then fails.
+     */
+    private untilRegistered;
+    /**
+     * Where the run stands, as a step check reads it: passed once it succeeded,
+     * throwing when it ended any other way, and otherwise its status and page.
+     * `live` says whether the registry already serves the package, which is
+     * all that passes a release that never started a run.
+     */
+    watch(name: string, live: boolean): Promise<CheckReport>;
+    private failure;
+    /** What to run for npm to trust the workflow, once per package. */
+    private setup;
+}

package/vendor/core/ship/registry/npm-registry.d.ts

@@ -0,0 +1,70 @@
+import type { Logger } from "../../log/index.js";
+import { type Ps } from "../../system/index.js";
+import { Duration } from "../../time/index.js";
+import type { CheckReport } from "../step";
+import type { Package } from "../workspace/workspace";
+import type { GithubActions } from "./github-actions";
+import type { Publication, Registry } from "./registry";
+/** Pass `ps` to run `NpmRegistry`'s npm commands through a fake in tests; the real processes by default. */
+export interface NpmRegistryOptions {
+    ps?: Ps;
+    /**
+     * Publish as npm's trusted publishing wants it, from a CI job that npm
+     * trusts: a plain `npm publish` that npm authorizes from the job's OIDC
+     * identity, with no token, no login and no stage. `trusted()` makes one.
+     */
+    trusted?: boolean;
+    /**
+     * Publish by running the generated workflow on GitHub Actions, where npm
+     * trusts the job, instead of staging from this machine: no token, no
+     * login and no approval. `githubActions()` makes one.
+     */
+    via?: GithubActions;
+}
+/**
+ * Use it to stage packages on npm and read back what npm holds. A stage-only
+ * token will do, and a person approves each version on npmjs.com; npm then
+ * scans it, typically for about five minutes, before anyone can install it.
+ */
+export declare class NpmRegistry implements Registry {
+    readonly staged: boolean;
+    readonly scans = true;
+    readonly publishDeadline?: Duration;
+    /** Set only for a `via` publish, whose run it follows. */
+    readonly watch?: (name: string, version: string) => Promise<CheckReport>;
+    /** Set only for a `via` publish, whose workflow npm has to trust. */
+    readonly trust?: (name: string, log: Logger) => Promise<void>;
+    private readonly ps;
+    private readonly isTrusted;
+    private readonly via?;
+    private authed?;
+    private saidSkip;
+    constructor(opts?: NpmRegistryOptions);
+    /**
+     * `npm trust github`, run where the person can see it: npm asks them to
+     * authenticate in a browser, even to list what a package trusts.
+     */
+    private trustWorkflow;
+    /**
+     * Refuses a package going out through a run whose `repository.url` is not
+     * the run's repository: npm checks the two match against the provenance
+     * the run signs, and refuses the publish otherwise.
+     */
+    verify({ name, repository: url }: Package): Promise<void>;
+    trusted(): Registry;
+    pack(dir: string, into: string): Promise<void>;
+    published(name: string, version: string): Promise<boolean>;
+    deployed(name: string): Promise<string | undefined>;
+    publish(dir: string): Promise<Publication>;
+    /**
+     * `npm publish` from a job npm trusts. Verbose, because a package with no
+     * matching trusted publisher entry fails with the same 404 as a logged-out
+     * publish, and only the verbose log says the OIDC exchange is what refused.
+     */
+    private publishTrusted;
+    page(name: string, version: string): string;
+    /** `npm stage` arrived in npm 11.15; older CLIs die with a bare "Unknown command". */
+    private checkVersion;
+    /** Runs `npm login` unless somebody is already logged in. NPM_TOKEN counts. */
+    private login;
+}

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

@@ -0,0 +1,31 @@
+import { type Logger } from "../../log/index.js";
+import { Duration } from "../../time/index.js";
+import type { Artifact, Stage } from "../artifact/artifact";
+import type { Cut } from "../cut";
+import type { CheckReport, Step, StepReport } from "../step";
+import type { Registry } from "./registry";
+/** One package, published through the registry that carries it. */
+export declare class RegistryArtifact implements Artifact {
+    readonly name: string;
+    private readonly registry;
+    readonly packages: readonly string[];
+    readonly stage: Stage;
+    /** Set only when the registry has a CI job to trust. */
+    readonly trust?: (log: Logger) => Promise<void>;
+    /** Set only when the registry checks a package before it goes out. */
+    readonly verify?: (cut: Cut) => Promise<void>;
+    private saidHeld;
+    /** What the handed-off run was doing when last looked in on, to log each change once. */
+    private runStatus?;
+    constructor(name: string, registry: Registry);
+    trusted(): Artifact;
+    deployed(): Promise<string | undefined>;
+    steps(cut: Cut): readonly Step[];
+    /** Packs what `publish` would send into the dry run's packs, or says it would send it. */
+    private pack;
+    /** The check that follows a publish handed off to a run elsewhere, when this registry has one. */
+    private watching;
+    /** Whether the version is installable yet, and if not, what it may be waiting on. */
+    live(cut: Cut, waited: Duration): Promise<CheckReport>;
+    publish(cut: Cut, report?: StepReport): Promise<void>;
+}