toolroll 0.9.104 → 0.9.105

package/dist/push.d.ts

@@ -1,120 +0,0 @@
-/**
- * Web push, zero-dependency (arc 3).
- *
- * Three layers, kept apart: CRYPTO (RFC 8291 aes128gcm message encryption
- * and RFC 8292 VAPID authorization, byte-exact, node:crypto only),
- * TRANSPORT (one hardened fetch to an allow-listed push service), and the
- * PASS (claim pairs from the store's ledger, fence, send, settle by the
- * full outcome table). The payload that transits Apple's and Google's
- * servers is a fixed phrase keyed on the notification's CLASS plus a
- * machine-minted console path. Check progress may also send one validated
- * suite/count line; task titles, branches and repository names stay local.
- *
- * 'accepted' means the push service took the message (RFC 8030). Nothing
- * here ever claims a phone displayed anything, and delivery is
- * AT-LEAST-ONCE: a crash between acceptance and settlement re-sends after
- * the pair's lease expires (the payload's tag collapses the duplicate on
- * the lock screen).
- */
-import { createECDH } from "node:crypto";
-import type { Notification, Store } from "./store.js";
-export declare const VAPID_FILE = "vapid-keys.json";
-/** The plaintext ceiling that keeps one record inside rs (RFC 8291 §4). */
-export declare const PLAINTEXT_CEILING = 3993;
-/** The pair lease strictly exceeds the request timeout (finding 12). */
-export declare const PUSH_CLAIM_TTL_MS = 30000;
-export type VapidKeys = {
-    /** 65-byte uncompressed P-256 point, base64url. */
-    publicKey: string;
-    /** 32-byte scalar, base64url. */
-    privateKey: string;
-    fingerprint: string;
-};
-export declare function vapidFingerprint(publicKey: string): string;
-/** Load the saved pair only (null when none is saved yet): what a page reads (docs/plans/get-side-effects.md). */
-export declare function loadVapidKeys(dir: string): VapidKeys | null;
-/**
- * Mint-or-load, atomically across processes (finding 29): exclusive
- * creation; the loser of a race re-reads the winner's file; and a loaded
- * pair is VALIDATED — the stored public key must derive from the stored
- * private key, or the file is refused rather than trusted.
- */
-export declare function loadOrCreateVapidKeys(dir: string): VapidKeys;
-/**
- * The deterministic core, exported for the Appendix A vector test: given
- * the subscriber's materials, an application-server ECDH object, and a
- * salt, produce the complete aes128gcm body — header || ciphertext.
- */
-export declare function encryptWithMaterials(uaPublic: Buffer, authSecret: Buffer, asKeys: ReturnType<typeof createECDH>, salt: Buffer, plaintext: Buffer): Buffer;
-/** The production wrapper: fresh ephemeral keys and a fresh salt per message. */
-export declare function encryptPushPayload(p256dh: string, auth: string, plaintext: string): Buffer;
-/**
- * The VAPID authorization header: an ES256 JWT over { aud, exp, sub? },
- * signed with the STABLE server key (distinct from every message's
- * ephemeral key), in JWS P1363 form — never DER (finding 4).
- */
-export declare function vapidAuthorization(endpoint: string, keys: VapidKeys, now: Date, contact?: string): string;
-export declare function validatePushEndpoint(raw: string): {
-    ok: true;
-    url: URL;
-} | {
-    ok: false;
-    problem: string;
-};
-/** A push's class: a stored class, or `release`, which is never stored: it is derived at send time from the plane's own
- * state (release-approval.ts releasePushOf), never from a title, a task id or a link. */
-export type PushClass = NonNullable<Notification["pushClass"]> | "release";
-/** Fixed words, except for one validated machine-only suite/count line. */
-export declare const PUSH_WORDS: Record<PushClass, {
-    title: string;
-    body: string;
-}>;
-/** The relative links a push may carry (docs/plans/plain-toolroll.md P1.4): every shape an older worker took, kept for
- * good (/next and /review now redirect to Home and Tasks' Ready view; the rest keep their pages), then Home, Tasks'
- * Ready and Board views, and a task by its stored number (/n/<n>, resolved under the viewer's own access). */
-export declare const LINK_SHAPES: readonly RegExp[];
-/** Static words and machine-minted numbers only — re-proved at send time. */
-export declare function safePushLink(pushClass: PushClass, link: string | null): string;
-/** One line per ping (docs/plans/plain-toolroll.md P1.5), built only from the task's stored number and fixed words: no
- * title, no free text. A fact about a task opens that task (/n/<n>); anything else keeps its class's fixed words and
- * its own allow-listed link. Rows are tried in order; the first that matches says the line. */
-export declare const PUSH_LINES: readonly {
-    when: (notification: Pick<Notification, "kind" | "pushClass">) => boolean;
-    say: (number: number) => string;
-}[];
-/** The one line a ping says, and where its tap lands. */
-export declare function pushLineOf(notification: Pick<Notification, "kind" | "pushClass" | "body" | "link" | "taskRef">): {
-    body: string;
-    url: string;
-};
-/** `release`: the class and link the plane derived for this row at send time (releasePushOf): fixed words and a release's
- * own link, never the task line. Absent or null, the row's own line. */
-export declare function buildPushPayload(notification: Notification, waiting?: number | null, release?: {
-    link: string;
-} | null): string;
-export type PushFetch = (url: string, init: Record<string, unknown>) => Promise<{
-    status: number;
-    headers: {
-        get(name: string): string | null;
-    };
-}>;
-export type PushPassReport = {
-    seeded: number;
-    accepted: number;
-    rescheduled: number;
-    rejected: number;
-    retired: number;
-    credentialProblem: boolean;
-};
-/**
- * One pass: seed, claim, and for each pair — renew, fence, encrypt, send,
- * settle by the outcome table. Every settle is conditional on the claim's
- * owner AND generation; a lapsed claim writes nothing.
- */
-export declare function pushPass(store: Store, options: {
-    configDir: string;
-    fetchImpl?: PushFetch;
-    clock?: () => Date;
-    owner?: string;
-    contact?: string;
-}): Promise<PushPassReport>;

package/dist/quality.d.ts

@@ -1,8 +0,0 @@
-/**
- * How much evidence work a task asks Toolroll to do after the
- * builder finishes. This is deliberately separate from operating modes
- * (authority/autonomy) and unattended permissions (provider sandboxing).
- */
-export type QualityMode = "default" | "strict";
-export declare function isQualityMode(value: unknown): value is QualityMode;
-export declare function qualityModeTitle(mode: QualityMode): string;

package/dist/quick-start.d.ts

@@ -1,26 +0,0 @@
-import { type AttachProof, type AttachSeams } from "./console-instance.js";
-export type QuickStartSeams = {
-    databaseFile: string;
-    cwd: string;
-    env: Record<string, string | undefined>;
-    build: string;
-    /** The repository's top folder for a directory, or null outside one. */
-    findRepo: (cwd: string) => Promise<string | null>;
-    /** Whether this installation already admitted the repository. */
-    enrolled: (repo: string) => Promise<boolean>;
-    /** The ordinary admission (`repos add`): its registry lock and ceilings, from this CLI's own database. */
-    admit: (repo: string) => Promise<number>;
-    /** `up`, for this repository. */
-    startUp: () => Promise<number>;
-    openBrowser: (url: string) => void | Promise<void>;
-    terminal: boolean;
-    attach?: AttachSeams;
-    /** Tests: the agent check (default: the environment and the process's ancestors). */
-    underAgent?: boolean;
-};
-/** Whether argv is a bare `toolroll` (nothing, or only --json). */
-export declare const isBareInvocation: (argv: readonly string[]) => boolean;
-/** This database's console, proved live without creating, migrating or changing anything (also easy-start.ts's). */
-export declare function proveConsoleReadOnly(databaseFile: string, build: string, attach?: AttachSeams): Promise<AttachProof>;
-/** null: not this command (outside a repository) — the caller scans as before. */
-export declare function runQuickStart(argv: readonly string[], write: (line: string) => void, seams: QuickStartSeams): Promise<number | null>;

package/dist/read-executor-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/read-executor.d.ts

@@ -1,66 +0,0 @@
-import type { Store } from './store.js';
-import { type WorkIndexOptions, type WorkIndexPage, type WorkProjectCounts } from './work-index.js';
-import type { BrowserProjectState } from './browser-workspace.js';
-import type { SidebarProject } from './console-chrome.js';
-import type { WorkSummaryAccess } from './work-summary.js';
-/**
- * Heavy, read-only database work for the server, run on worker threads (docs/server-performance.md).
- * Each worker owns one read-only, query-only connection to the server's own database file, so the
- * measured hot read (the work index behind `task list`) never holds the HTTP event loop. Callers
- * authorize first and send only the already-admitted access; a worker never widens it, writes, or
- * retries. Without a file-backed database (tests, the demo) nothing is attached and callers keep
- * running the same builder in-process.
- */
-export type ReadJob = {
-    kind: 'work-index-page';
-    now: string;
-    access: WorkSummaryAccess;
-    options: WorkIndexOptions;
-} | {
-    kind: 'work-counts';
-    now: string;
-    access: WorkSummaryAccess;
-} | {
-    kind: 'project-summary';
-    now: string;
-    access: WorkSummaryAccess;
-    actor: string;
-    projects: SidebarProject[];
-    evidenceRoot: string | null;
-};
-export type ReadReply = {
-    id: number;
-    ok: true;
-    value: unknown;
-} | {
-    id: number;
-    ok: false;
-    error: {
-        name: string;
-        message: string;
-    };
-};
-/** More queued reads than this fail at once instead of growing without bound. */
-export declare const READ_QUEUE_MAX = 1000;
-export declare class ReadExecutorError extends Error {
-    constructor(message: string);
-}
-export declare class ReadExecutor {
-    #private;
-    constructor(file: string, size?: number);
-    get size(): number;
-    /** workIndexPage(store, now, access, options) on a worker's read-only connection: same rows, same errors. */
-    workIndexPage(now: Date, access: WorkSummaryAccess, options: WorkIndexOptions): Promise<WorkIndexPage>;
-    /** workCountsByProject(store, now, access) on a worker: the console's Tasks count and live beat. */
-    workCounts(now: Date, access: WorkSummaryAccess): Promise<WorkProjectCounts[]>;
-    /** projectSummaryOf (console-chrome.ts) on a worker: the sidebar's project states for one already-admitted reader. */
-    projectSummary(now: Date, access: WorkSummaryAccess, actor: string, projects: readonly SidebarProject[], evidenceRoot: string | undefined): Promise<BrowserProjectState[]>;
-    /** Fails every queued and running read once, then stops the workers. */
-    close(): Promise<void>;
-}
-/** Half the cores, at most eight: the measured 20-engineer load needs over four (docs/server-performance.md),
- * and the rest stay with the event loop and local agents. Workers start only when reads arrive. */
-export declare function defaultReadWorkers(): number;
-/** The server attaches its executor to its own Store; a command run on that Store reads through it. */
-export declare function attachReadExecutor(store: Store, executor: ReadExecutor): () => void;
-export declare function readExecutorOf(store: Store): ReadExecutor | null;

package/dist/read-only-request.d.ts

@@ -1,4 +0,0 @@
-/** Run a GET or HEAD request's work. */
-export declare function asReadOnlyRequest<T>(work: () => T): T;
-/** Whether the current work answers a GET or HEAD request. */
-export declare function inReadOnlyRequest(): boolean;

package/dist/recipe-ui.d.ts

@@ -1,21 +0,0 @@
-import { type Recipe, type RecipeDocument, type WorkflowPreview } from "./recipes.js";
-import { type Html } from "./html.js";
-export declare function recipeFromForm(body: URLSearchParams): RecipeDocument;
-/** "One-time work" (New flow): the open project's recipes and the starters as rows, each with one "Use this"; then
- * Create a recipe, importing a shared one, and the work recipes made lately. */
-export declare function recipeRowsHtml(starters: Recipe[], saved: Recipe[], project: string | null, projectName: string | null, revision: number, recent: {
-    name: string;
-    href: string;
-    state: string;
-}[]): Html;
-export declare function recipeEditorHtml(recipe: Recipe, repo: string, revision: number, problem?: string | null, values?: URLSearchParams, creator?: boolean): Html;
-export declare function workflowPreviewHtml(preview: WorkflowPreview, revision: number, now: Date, readiness: {
-    title: string;
-    detail: string;
-    href?: string;
-}[], auto: boolean): Html;
-export declare function recipeDefinitionPreviewHtml(preview: WorkflowPreview, revision: number): Html;
-export declare function recipeRunHtml(recipe: Recipe, repo: string, revision: number, problem?: string | null, values?: URLSearchParams, saved?: boolean): Html;
-export declare function recipeAnswersFromForm(body: URLSearchParams): Map<string, string>;
-export declare function recipeScript(): string;
-export declare const RECIPE_CSS = "\n.fl-recipe-more { display:grid; gap:12px; padding-top:12px; }.fl-recipe-more .k-disclose[open] > form, .fl-recipe-more .k-disclose[open] > div { margin-top:12px; }.fl-recipe-import { display:grid; gap:12px; margin:0; }\n.fl-recipe-recent { display:grid; }.fl-recipe-recent a { display:flex; justify-content:space-between; gap:12px; min-height:40px; align-items:center; border-bottom:1px solid var(--so-line); color:var(--so-ink); text-decoration:none; font-size:13px; }\n.recipe-heading { margin: .5rem 0 1.75rem; max-width: 46rem; }\n.recipe-heading h1 { font-size: clamp(1.65rem,3vw,2.5rem); letter-spacing:-.035em; margin:.35rem 0 .6rem; }\n.recipe-kicker { font-size:.7rem; text-transform:uppercase; letter-spacing:.12em; color:var(--muted-foreground); }\n.recipe-grid { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:.8rem; margin:1rem 0 2rem; }\n.recipe-card { border:1px solid var(--border); border-radius:var(--radius); padding:1.1rem; background:var(--card); display:flex; flex-direction:column; gap:.5rem; }\n.recipe-card h3 { font-size:1.05rem; margin:0; letter-spacing:-.015em; }\n.recipe-card p { color:var(--muted-foreground); margin:.2rem 0; font-size:.85rem; line-height:1.5; }\n.recipe-card-link { margin-top:auto; padding-top:.75rem; display:flex; justify-content:space-between; }\n.recipe-editor { max-width:52rem; }.recipe-editor h2 { margin-top:0; }\n.recipe-criterion { border:1px solid var(--border); border-radius:calc(var(--radius) - 3px); padding:.8rem; margin:.8rem 0; }\n.recipe-evidence { display:flex; flex-wrap:wrap; gap:.5rem 1rem; }.recipe-evidence label { display:flex; align-items:center; gap:.4rem; font-size:.8rem; }.recipe-evidence input { width:auto; margin:0; }\n.recipe-options { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }\n.recipe-preview-grid { display:grid; grid-template-columns:minmax(0,1.7fr) minmax(16rem,1fr); gap:1rem; }\n.recipe-steps { padding-left:1.4rem; }.recipe-steps li { padding:.4rem 0 .6rem .3rem; }.recipe-steps p { margin:.3rem 0 0; font-size:.85rem; color:var(--muted-foreground); }\n.recipe-launch { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }.recipe-launch form { margin:0 0 .6rem; }\n.recipe-history a { display:flex; justify-content:space-between; gap:1rem; padding:.6rem 0; border-bottom:1px solid var(--border); }.recipe-history span { color:var(--muted-foreground); }\n.recipe-error { border-color:var(--destructive); }\n.recipe-card[hidden] { display:none; }.recipe-search { max-width:28rem; }.recipe-question { border:1px solid var(--border); border-radius:calc(var(--radius) - 3px); margin:1rem 0; padding:.8rem; min-width:0; }.recipe-run { max-width:42rem; }.recipe-run button { margin-top:1rem; }\n@media(max-width:1000px){.recipe-grid { grid-template-columns:repeat(2,minmax(0,1fr)); }}\n@media(max-width:760px){.recipe-grid,.recipe-options,.recipe-preview-grid,.recipe-launch { grid-template-columns:1fr; }.recipe-heading { margin-bottom:1rem; }.recipe-history a { flex-direction:column; gap:.2rem; }}\n";

package/dist/recipes.d.ts

@@ -1,56 +0,0 @@
-import type { Store } from "./store.js";
-import { type RecipeDocument } from "./contracts/recipes.js";
-export declare const RECIPE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS workflow_recipe (\n  id TEXT NOT NULL, revision INTEGER NOT NULL CHECK(revision > 0),\n  repo TEXT NOT NULL, document TEXT NOT NULL, digest TEXT NOT NULL,\n  author TEXT NOT NULL, created_at TEXT NOT NULL,\n  PRIMARY KEY(id, revision)\n);\nCREATE INDEX IF NOT EXISTS workflow_recipe_project ON workflow_recipe(repo, id, revision DESC);\nCREATE TRIGGER IF NOT EXISTS workflow_recipe_no_update BEFORE UPDATE ON workflow_recipe\nBEGIN SELECT RAISE(ABORT, 'recipe revisions are immutable'); END;\nCREATE TRIGGER IF NOT EXISTS workflow_recipe_no_delete BEFORE DELETE ON workflow_recipe\nBEGIN SELECT RAISE(ABORT, 'recipe revisions are immutable'); END;\nCREATE TABLE IF NOT EXISTS workflow_preview (\n  token TEXT PRIMARY KEY, actor TEXT NOT NULL, repo TEXT NOT NULL,\n  document TEXT NOT NULL, digest TEXT NOT NULL, source TEXT NOT NULL,\n  created_at TEXT NOT NULL, expires_at TEXT NOT NULL,\n  -- routine_id: history (routines became scheduled flows in v115; the flow_id column is added after this runs).\n  task_id TEXT REFERENCES task(id), routine_id INTEGER,\n  saved_id TEXT, saved_revision INTEGER,\n  CHECK(task_id IS NULL OR routine_id IS NULL),\n  FOREIGN KEY(saved_id, saved_revision) REFERENCES workflow_recipe(id, revision)\n);\nCREATE INDEX IF NOT EXISTS workflow_preview_project ON workflow_preview(repo, created_at DESC);\nCREATE INDEX IF NOT EXISTS workflow_preview_source ON workflow_preview(repo, source, created_at DESC)\nWHERE task_id IS NOT NULL OR routine_id IS NOT NULL;\n";
-export type { RecipeDocument, RecipeInput } from "./contracts/recipes.js";
-export declare const RECIPE_INPUT_LIMIT: 8;
-export type RecipeAnswers = ReadonlyMap<string, string>;
-export type Recipe = {
-    id: string;
-    revision: number;
-    repo: string | null;
-    document: RecipeDocument;
-    digest: string;
-    author: string;
-};
-export type WorkflowPreview = {
-    token: string;
-    actor: string;
-    repo: string;
-    document: RecipeDocument;
-    digest: string;
-    source: string;
-    expiresAt: string;
-    taskId: string | null;
-    flowId: number | null;
-    savedId: string | null;
-    savedRevision: number | null;
-};
-export declare class RecipeError extends Error {
-    readonly status: number;
-    constructor(message: string, status?: number);
-}
-/** Reject unknown fields, including approval/provider settings, on import. */
-export declare function parseRecipe(input: unknown): RecipeDocument;
-export declare function importRecipe(text: string): RecipeDocument;
-export declare const recipeDigest: (document: RecipeDocument) => string;
-export declare const exportRecipe: (document: RecipeDocument) => string;
-export declare function resolveRecipe(document: RecipeDocument, answers: RecipeAnswers): RecipeDocument & {
-    version: 1;
-};
-/** Only the stored definition supplies scope; form answers cannot replace it. */
-export declare function prepareRecipeRun(store: Store, actor: string, repo: string, id: string, revision: number, answers: RecipeAnswers, now: Date): WorkflowPreview;
-export declare function starterRecipes(): Recipe[];
-export declare function savedRecipes(store: Store, actor: string, repo: string): Recipe[];
-export declare function findRecipe(store: Store, actor: string, repo: string | null, id: string, revision?: number): Recipe | null;
-export declare function createWorkflowPreview(store: Store, actor: string, repo: string, document: RecipeDocument, source: string, now: Date): WorkflowPreview;
-export declare function workflowPreview(store: Store, actor: string, repo: string, token: string): WorkflowPreview | null;
-export declare function launchWorkflow(store: Store, actor: string, repo: string, token: string, now: Date, operatorFiling: boolean): {
-    taskId: string | null;
-    flowId: number | null;
-};
-export declare function saveWorkflowRecipe(store: Store, actor: string, repo: string, token: string, now: Date): Recipe;
-export declare function workflowSteps(document: RecipeDocument): {
-    title: string;
-    detail: string;
-}[];
-export declare function recipeScheduleWords(document: RecipeDocument, now: Date): string;

package/dist/release-adapters.d.ts

@@ -1,205 +0,0 @@
-/**
- * The world `toolroll release` acts on (release.ts): the gate checkout through git, GitHub through the signed-in `gh`,
- * the npm registry over HTTPS, the installed Toolroll through its own CLI (`--json`) and launchd definitions, and the
- * Homebrew tap through `gh`. Each call is bounded; none asks for or stores a credential — `gh`, npm and Toolroll use
- * the sign-ins this machine already has.
- */
-import type { CheckRun, GateState, Installed, MainProtection, ReleaseAdapters } from "./release.js";
-import { Store } from "./store.js";
-import { type CiObservation } from "./release-auto.js";
-import { type BuildRunner } from "./release-carry.js";
-import { type GhRead } from "./nightly-github.js";
-export { failedBeforeTests, type JobRecord } from "./github-jobs.js";
-import { type ReleaseRepo, type ReleaseTools } from "./release-git.js";
-export { RELEASE_PATH, RELEASE_REMOTE, releaseConfigProblem, releaseGitArgs, releaseGitEnv, releaseRemote, releaseTools, type ReleaseRepo, type ReleaseTools } from "./release-git.js";
-export type Exec = (command: string, args: readonly string[], options?: {
-    cwd?: string;
-    timeoutMs?: number;
-    env?: NodeJS.ProcessEnv;
-    input?: string;
-}) => Promise<{
-    code: number;
-    stdout: string;
-    stderr: string;
-}>;
-/** A child process, its output kept whole; a missing program or a time limit is exit 127 or 124, never a throw. */
-export declare const exec: Exec;
-/** owner/name from an https or ssh GitHub remote. */
-export declare function githubSlug(url: string): string | null;
-/** The runtime (a `dist` folder, resolved) each launchd service of Toolroll runs: its definition names `<dist>/cli.js`. */
-export declare function serviceRuntimes(agents?: string): string[];
-/** The runtime each CLI name resolves to on PATH: the `dist` folder its `bin.js` sits in, or null when not linked there. */
-export declare function cliRuntimes(path?: string, names?: string[]): Installed["clis"];
-type Json = Record<string, unknown>;
-/** `task show --json`, read as the release needs it. */
-export declare function gateStateOf(answer: Json, accounts?: readonly unknown[]): GateState;
-/** Every process on this machine (`ps`): pid and full command line. */
-export declare function processes(): {
-    pid: number;
-    command: string;
-}[];
-/** The final line of deploy-browser's output that is a JSON object: its `runtime` (a dist folder), when it has one. */
-export declare function deployedRuntime(stdout: string): string | null;
-/** What a deployment's stage says about the update pause: its id and phase when the journal is before the swap and the
- * live database's pause is that deployment's. `owner` reads the live pause's owner. */
-export declare function stageGate(stage: string, owner: () => string | null): {
-    id: string;
-    phase: string;
-} | null;
-/** The recorded repository for a gate checkout, from the plane's database; throws in plain words when there is none. */
-export declare function recordedReleaseRepo(database: string, checkout: string): ReleaseRepo;
-export type AdapterOptions = {
-    checkout: string;
-    /** The recorded repository and the programs, when a caller (a test) supplies them; otherwise read from the plane's
-     * records and found on this machine when the first Git command runs. */
-    releaseRepo?: ReleaseRepo;
-    tools?: ReleaseTools;
-    /** The live database (default: this installation's). */
-    database?: string;
-    processes?: typeof processes;
-    /** owner/name of the Homebrew tap and its formula's path there. */
-    tap?: string;
-    formula?: string;
-    /** How long the deployment itself may run, in minutes. */
-    deployMinutes?: number;
-    /** The Toolroll CLI the release calls, as [program, ...leading args]; by default this runtime's own bin.js. */
-    cli?: readonly string[];
-    run?: Exec;
-    fetch?: typeof fetch;
-    say?: (line: string) => void;
-    now?: () => Date;
-    sleep?: (ms: number) => Promise<void>;
-};
-/** How many times, and how far apart, a merged branch's deletion is looked for after the push lost a race. */
-export declare const BRANCH_GONE_LOOKS = 5;
-export declare const BRANCH_GONE_PAUSE_MS = 2000;
-export declare function releaseAdapters(options: AdapterOptions): ReleaseAdapters;
-/**
- * Why a tap change isn't exactly the formula bump this release proposed (security scan), or null when it is: the tap's
- * own open pull request number `pr` at exactly `head`, from its version branch into the default branch; compared with
- * the default branch's head it is one commit on top of exactly that head, changing exactly one file, the formula; and
- * the formula there is exactly today's with npm's published tarball and that tarball's own sha256.
- */
-export declare function tapChangeProblem(input: {
-    tap: string;
-    pr: number;
-    head: string;
-    version: string;
-    formula: string;
-    defaultBranch: string;
-    baseHead: string;
-    baseVersion: string | null;
-    view: Json;
-    compare: Json;
-    expected: string;
-    atHead: string;
-    sha256: string;
-}): string | null;
-/** Whether a pull request's head is a branch of the tap itself (never a fork's). */
-export declare function tapOwnHead(pr: Json, tap: string): boolean;
-/** The version a formula's tarball url names (`…/toolroll-<x.y.z>.tgz`), or null. */
-export declare function formulaVersion(text: string): string | null;
-/** Whether version `a` comes after `b` (both x.y.z). */
-export declare function versionAfter(a: string, b: string): boolean;
-/**
- * Whether a workflow's triggers (its top-level `on:` as a name, a list or a map) include a change to the repository.
- * A file that doesn't parse, or whose triggers aren't one of those shapes, counts as running, so the release waits
- * rather than skipping checks it owes.
- */
-export declare function workflowRunsOnChange(text: string): boolean;
-/** The formula with its first `url` and `sha256` replaced; anything else is left exactly as it was. */
-export declare function bumpFormula(text: string, url: string, sha256: string): string;
-/**
- * The release's authority record through a store (release-once.md): what `toolroll release` reads and writes for its
- * lease, its carries and its operations. `open` hands a store for each call and `done` lets it go.
- */
-export declare function storeReleaseAdapter(open: () => Store, done: (store: Store) => void, now: () => Date, runner?: BuildRunner, 
-/** Releases that approve themselves (auto-approve-green.md): the plane's own look at CI on a commit, and where the
- * check receipts are kept. Absent: no automatic approval, every release asks a person. */
-auto?: AutoObservers, 
-/** GitHub's nightly (nightly-github.ts): the plane's own gh reads for a boundary's one bounded read. Absent: nothing
- * is read at the boundary, and the stored debt still holds inside every reservation. */
-nightlyReads?: GhRead): NonNullable<ReleaseAdapters["release"]>;
-/** What the plane itself reads for an automatic release approval. */
-export type AutoObservers = {
-    /** The plane's executor policy, never a report field or project setting. Unknown refuses. Production currently
-     * cannot establish this; synthetic observers may supply protected execution to exercise the remaining gates. */
-    reportsProtected?: boolean;
-    observe: (sha: string) => Promise<CiObservation>;
-    /** GitHub's merge base of `sha` with the branch `base` of the recorded repository. */
-    mergeBase: (base: string, sha: string) => Promise<string>;
-    /** Whether main's protection holds for the account that merges (readMainProtection); null when unreadable. */
-    upToDateRequired: () => Promise<boolean | null>;
-    evidenceRoot: string;
-    /** The cases that ran in `sha`'s macOS CI (fenced-check-coverage.ts); null when they can't be read. Absent: never read. */
-    macosCases?: (sha: string) => Promise<ReadonlyMap<string, boolean> | null>;
-};
-/**
- * Every check run GitHub holds for one commit — every attempt, not only the latest (`filter=all`; GitHub's default
- * lists only the latest of each), every page — with its id, app, check suite and the commit it is filed under, oldest
- * first. A row that doesn't parse stops the read: a partial answer is never taken for the whole.
- */
-export declare function readCheckRuns(run: Exec, gh: string, repo: string, sha: string, 
-/** A release tag (pipeline-speed.md, item 3): a push of exactly this tag binds its workflow file too. */
-options?: {
-    tag?: string;
-}): Promise<CheckRun[]>;
-/** GitHub's job record for one check run (its job), read strictly: null when it can't be read whole. */
-export declare function readJobBeforeTests(run: Exec, gh: string, repo: string, id: number): Promise<boolean | null>;
-/**
- * GitHub's REST API as GitHub's nightly reads it (nightly-github.ts): GET only, github.com only, a repository path, the
- * plane's own gh with the allowlisted environment, each call bounded by its caller's deadline. A background read rides
- * out a short network failure (release-net.ts, within that call's own share of the deadline); a boundary's read is
- * plain exec. Never an answer that isn't GitHub's whole JSON.
- */
-export declare function githubReads(run: Exec, gh: string, options?: {
-    retry?: boolean;
-}): (path: string, timeoutMs: number) => Promise<{
-    ok: true;
-    body: unknown;
-} | {
-    ok: false;
-    why: string;
-}>;
-/** GitHub lists check runs from at most the latest 1000 check suites of a commit: the history is whole only below that. */
-export declare const CHECK_SUITE_CEILING = 1000;
-export declare function readSuitesComplete(run: Exec, gh: string, repo: string, sha: string): Promise<boolean>;
-/** GitHub's merge base of `sha` with branch `base` (the compare API), read by the plane. */
-export declare function readMergeBase(run: Exec, gh: string, repo: string, base: string, sha: string): Promise<string>;
-/**
- * Main's head as GitHub has it now (eval-harness review 1, finding 4): read by the plane's own gh from GitHub's API,
- * never from a ref in a checkout a build can write.
- */
-export declare function readMainHead(run: Exec, gh: string, repo: string, branch?: string): Promise<string>;
-/** GitHub's own "Update branch", with its expected head: a push that got there first refuses. */
-export declare function updatePullRequestBranch(run: Exec, gh: string, repo: string, pr: number, expectedHead: string): Promise<{
-    ok: true;
-} | {
-    ok: false;
-    why: string;
-}>;
-/** Whether `sha` already holds `ancestor` (GitHub's compare: `sha` is not behind it), as GitHub answers now. */
-export declare function readContains(run: Exec, gh: string, repo: string, sha: string, ancestor: string): Promise<boolean>;
-/**
- * Main's protection, judged for the principal that merges (eval-harness review 2, finding 1; review 1, finding 4): the
- * plane's own gh, which merges as the same account. A layer holds only when it requires branches to be up to date, names
- * a non-empty set of required checks covering PROTECTION_MINIMUM_CHECKS, bound to GitHub Actions (app 15368), and
- * can't be bypassed by that account:
- * classic protection with "Do not allow bypassing the above settings" (`enforce_admins`); an active ruleset whose
- * bypass list reads whole, names no role, team or organization admin, and says this account never bypasses it. Read
- * only — Toolroll never changes a repository's settings. A layer that can't be read never holds. When no layer holds
- * and one couldn't be read (gh failed for a reason other than "not protected", or its answer didn't parse), the read
- * throws ProtectionUnreadable: "couldn't read GitHub" is never reported as "protection doesn't hold", and never as
- * holding. Null only for a repository or branch name GitHub can't be asked about.
- */
-export declare function readMainProtection(run: Exec, gh: string, repo: string, branch?: string): Promise<MainProtection | null>;
-/** Main's protection couldn't be read from GitHub (after the network retries): not "doesn't hold", and never "holds". */
-export declare class ProtectionUnreadable extends Error {
-    readonly unread: readonly string[];
-    constructor(unread: readonly string[]);
-}
-/** Whether main's protection holds, as a yes/no (release-auto.ts sealAutoGreen): null when it can't be read. */
-export declare function readUpToDateRequired(run: Exec, gh: string, repo: string, branch?: string): Promise<boolean | null>;
-/** The release's step record (store.ts release_step, v146) through a store opened for each entry: a failure to open or
- * write is swallowed, so recording never stops or changes the release. */
-export declare function releaseProgressRecorder(open: () => Store, done: (store: Store) => void): NonNullable<ReleaseAdapters["progress"]>;