toolroll 0.9.104 → 0.9.105

package/dist/assignment-ui.d.ts

@@ -1,68 +0,0 @@
-/** Presentation only. Assignment state and retry authority belong to their
- * existing projections and signed operating-mode terms, never this renderer. */
-import type { AssignmentSnapshot } from './assignment.js';
-import type { DisplayStatus, StatusTone, WorkStatus } from './workspace-ui.js';
-import { type AssignmentStatusOptions, type AssignmentWorkStatus } from './assignment-presentation.js';
-import { type PullRequestFact, type TaskStatus } from './task-status.js';
-import { type Html } from './html.js';
-/** The existing verified receipt reader may discover damage after a verdict
- * was saved. Keep the limitation visible without inventing another work stage. */
-export declare function assignmentWithEvidence(assignment: AssignmentSnapshot, resultStatus: DisplayStatus | null, resultRunId?: number | null): AssignmentSnapshot;
-export declare function assignmentStatusOf(assignment: AssignmentSnapshot, workStatus?: AssignmentWorkStatus): WorkStatus;
-/** Navigation only. A control action still opens its existing exact ceremony. */
-export declare function assignmentActionHref(assignment: AssignmentSnapshot): string | null;
-export type AssignmentAttemptRow = {
-    taskId: string;
-    label: string;
-    href: string;
-    runId: number | null;
-    detail: string | null;
-};
-/** Every version of the assignment, oldest first, as the card lists them. */
-export declare function assignmentAttemptsOf(assignment: AssignmentSnapshot): AssignmentAttemptRow[];
-export declare function assignmentAttemptsHtml(assignment: AssignmentSnapshot): Html;
-type AssignmentCardOptions = Omit<AssignmentStatusOptions, 'links'> & {
-    hideAction?: boolean;
-    problem?: boolean;
-    resultHref?: string;
-    pullRequest?: PullRequestFact | null;
-};
-/** The status card's content: one projection for the server HTML and the
- * rebuilt task page, so the two never word the same state differently. The
- * headline, sentence and detail rows are the shared task status; the exact
- * recorded reasons stay one tap away under Details, never as red text. */
-export type AssignmentCard = {
-    token: string;
-    tone: StatusTone;
-    label: string;
-    status: TaskStatus;
-    action: {
-        label: string;
-        href: string;
-        openResult: boolean;
-    } | null;
-    /** Exact technical reasons and diagnostics, shown on request. */
-    reasons: string[];
-    diagnostics: {
-        token: string;
-        label: string;
-        detail: string;
-    }[];
-    notices: {
-        summary: string;
-        lines: string[];
-    } | null;
-    attempts: AssignmentAttemptRow[];
-    lead: {
-        label: string;
-        active: boolean;
-    } | null;
-};
-export declare function assignmentCardOf(assignment: AssignmentSnapshot, options?: AssignmentCardOptions): AssignmentCard;
-export declare function assignmentSummaryHtml(assignment: AssignmentSnapshot, options?: AssignmentCardOptions & {
-    compact?: boolean;
-    sentence?: string | undefined;
-}): Html;
-/** Shared assignment layout; actions remain comfortable on touch screens. */
-export declare const ASSIGNMENT_CSS = ".assignment-summary{min-width:0;overflow-wrap:anywhere}.assignment-summary .assignment-state{font-weight:600;margin:0}.assignment-summary h2.assignment-state{font-size:1.125rem;color:var(--foreground)}.assignment-summary>.assignment-attempts,.assignment-summary>.assignment-notices{border:0;box-shadow:none;padding:0;margin:.25rem 0 0;background:transparent}.assignment-summary>.button-link{margin-top:.7rem;min-height:44px}.assignment-summary>.work-action{display:inline-flex;margin-inline-start:.6rem;min-height:44px;align-items:center}.assignment-detail{margin:.55rem 0}.assignment-attempts summary,.assignment-notices summary{min-height:44px;display:list-item;align-content:center;cursor:pointer}.assignment-notices summary{font-size:.8125rem;color:var(--foreground)}.assignment-notices p{margin:.25rem 0 .5rem}.assignment-attempts ol{padding-left:1.4rem}.assignment-attempts li{margin:.4rem 0}.assignment-attempts li a{display:inline-flex;align-items:center;min-height:44px;margin-right:.7rem}.assignment-attempts li p{margin:0 0 .4rem}";
-export {};

package/dist/assignment.d.ts

@@ -1,350 +0,0 @@
-import { type Store, type ProofVerdictRow, type ProofAcceptanceRow } from "./store.js";
-import { type WorkAction, type WorkSummaryAccess } from "./work-summary.js";
-import { type VerifiedApprover } from "./principal.js";
-import { type ProofVerdict } from "./proof.js";
-import { type CheckLevel } from "./check-levels.js";
-import { type BuildReviewView } from "./review-switch.js";
-import { type NeedKey, type WaitKey } from "./needs-you.js";
-import { type ChecksBatch, type CompletionBlocker } from "./task-status.js";
-import { type ReleaseCoverage, type ReleaseMemo } from "./release-coverage.js";
-import { type LeadClaim } from "./lead-voice.js";
-export type AssignmentAccess = WorkSummaryAccess;
-export type AssignmentOwner = {
-    kind: "coordinator" | "lead";
-    id: string;
-    label: string;
-};
-export type AssignmentChecks = {
-    status: "passed" | "failed" | "not-run" | "unavailable";
-    exitCode: number | null;
-    command: string | null;
-    logArtifactId: number | null;
-    detail: string;
-    /** Which check this is (check-levels.ts): quick, full, or off; null before levels. */
-    level?: CheckLevel | null;
-    /** A follow-up check waiting or running on this commit. */
-    running?: "quick" | "full" | null;
-    /** A batch check (batch-checks.ts): waiting for its batch, or how it was checked. */
-    batch?: ChecksBatch | null;
-    /** Checks Off: the passing full release check that contains this commit (release-coverage.ts), read now, never sealed. */
-    release?: ReleaseCoverage | null;
-    /** Why a saved check can't be read, when it is the project's check command approved again since it ran (its files
-     * are intact; running checks again settles it). Presentation only, never sealed. */
-    cause?: "command-changed" | null;
-};
-export type AssignmentReceipt = {
-    digest: string;
-    rootId: string;
-    taskId: string;
-    runId: number;
-    base: string | null;
-    head: string | null;
-    scopeDigest: string | null;
-    proof: ProofVerdictRow | null;
-    completionKind: "verified-build" | "checked-build" | "finished-build" | "research-report" | "accepted-exception" | null;
-    proofAcceptance: ProofAcceptanceRow | null;
-    checks: AssignmentChecks;
-    artifacts: {
-        id: number;
-        kind: string;
-        sha256: string;
-        bytes: number;
-        complete: boolean;
-    }[];
-    caveats: string[];
-    agentReport: string | null;
-    evidence: "recorded";
-};
-export type AssignmentSnapshot = {
-    version: 1;
-    rootId: string;
-    activeTaskId: string;
-    repo: string | null;
-    title: string;
-    state: "working" | "checking" | "needs-decision" | "ready-to-check" | "complete" | "cancelled";
-    detail: string;
-    primaryAction: WorkAction | null;
-    attention: string[];
-    attempts: {
-        taskId: string;
-        runId: number | null;
-        label: string;
-        detail: string;
-    }[];
-    owner: (AssignmentOwner & {
-        active: boolean;
-    }) | null;
-    receipt: AssignmentReceipt | null;
-    savedContext?: {
-        goal: string | null;
-        outOfScope: string | null;
-        excerpts: {
-            artifactId: number;
-            runId: number;
-            kind: string;
-            sha256: string;
-            text: string | null;
-            shortened: boolean;
-            problem: string | null;
-        }[];
-    };
-    /** `lead`: marked complete by the person's lead (`toolroll lead token`), shown as "by the lead". */
-    /** `landed`: Toolroll marked it complete because its work is already in main, and why ("its pull request merged"). */
-    completion: {
-        actor: string;
-        at: string;
-        digest: string;
-        lead?: true;
-        landed?: string;
-    } | null;
-    handoff: {
-        kind: "result" | "decision" | "attention";
-        digest: string;
-        acknowledged: boolean;
-    } | null;
-    publication: {
-        state: string;
-        prUrl: string | null;
-        remoteState: string | null;
-    } | null;
-    /** The result's one automatic review, when its project had review on:
-     * pending, HIGH findings, suggested follow-ups (MEDIUM/LOW), or not reviewed. */
-    review: BuildReviewView | null;
-    deployment: {
-        status: "not-recorded";
-    };
-    /** What this assignment asks of a person, or waits for when no person can act (needs-you.ts). */
-    need?: {
-        key: NeedKey;
-        build: number | null;
-    } | {
-        wait: WaitKey;
-        build: number | null;
-    } | null;
-    /** The person's lead took it on (lead-voice.ts): "<name> is on it" until done, handed on, or two quiet hours. */
-    lead?: LeadClaim | null;
-    /** How many earlier versions of this task are still queued or running; absent when none. */
-    earlierActive?: number;
-    /** Of those, how many are running rather than only queued; present with earlierActive. */
-    earlierRunning?: number;
-    /** The result as it reads today (task-status.ts): the verdict it shows, whether its checks were deliberately Off, and
-     * what refuses Complete. Derived at read time; never part of the sealed receipt. Null without a result. */
-    readiness?: {
-        verdict: ProofVerdict | null;
-        checksOff: boolean;
-        blockers: CompletionBlocker[];
-    } | null;
-};
-/** Status-first handoff for routine reads. Fetch get_assignment only when
- * inspecting its exact evidence; do not repeat a full proof in every poll. */
-export declare function assignmentBrief(assignment: AssignmentSnapshot | null): {
-    version: 1;
-    rootId: string;
-    activeTaskId: string;
-    state: "cancelled" | "checking" | "complete" | "needs-decision" | "ready-to-check" | "working";
-    detail: string;
-    owner: (AssignmentOwner & {
-        active: boolean;
-    }) | null;
-    primaryAction: WorkAction | null;
-    attention: string[];
-    attempts: number;
-    handoff: {
-        kind: "result" | "decision" | "attention";
-        digest: string;
-        acknowledged: boolean;
-    } | null;
-    completion: {
-        actor: string;
-        at: string;
-        digest: string;
-        lead?: true;
-        landed?: string;
-    } | null;
-    result: {
-        digest: string;
-        taskId: string;
-        runId: number;
-        base: string | null;
-        head: string | null;
-        completionKind: "accepted-exception" | "checked-build" | "finished-build" | "research-report" | "verified-build" | null;
-        checks: AssignmentChecks;
-        proofAcceptance: ProofAcceptanceRow | null;
-        verdict: "attested" | "refuted" | "short" | "verified" | null;
-        criteria: {
-            passed: number;
-            total: number;
-        };
-        evidence: "recorded";
-    } | null;
-    publication: {
-        state: string;
-        prUrl: string | null;
-        remoteState: string | null;
-    } | null;
-    review: BuildReviewView | null;
-    deployment: {
-        status: "not-recorded";
-    };
-    readiness: {
-        verdict: ProofVerdict | null;
-        checksOff: boolean;
-        blockers: CompletionBlocker[];
-    } | null;
-} | null;
-export declare function assignmentChecksForRun(store: Store, root: string | undefined, runId: number, now: Date): AssignmentChecks;
-export declare function assignmentOf(store: Store, taskId: string, now: Date, access: AssignmentAccess, root?: string, memo?: ReleaseMemo): AssignmentSnapshot | null;
-type MutationResult = {
-    ok: true;
-    assignment: AssignmentSnapshot;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-export declare function claimAssignment(store: Store, taskId: string, owner: AssignmentOwner, now: Date, root?: string): MutationResult;
-/** Diagnostic only: artifact availability does not authorize or block a human
- * handoff. Deployment independently validates its actual native check. */
-export declare function assignmentEvidenceIntact(store: Store, root: string, receipt: AssignmentReceipt): boolean;
-export declare function checkAssignment(store: Store, taskId: string, receiptDigest: string, owner: AssignmentOwner, now: Date, root?: string): MutationResult;
-/** The signed-in user can mark the same exact receipt handled without taking
- * lead ownership. This records review, never check success or new authority. */
-export declare function checkAssignmentAsOperator(store: Store, taskId: string, receiptDigest: string, who: VerifiedApprover, now: Date, root?: string): MutationResult;
-/** The acceptance's own ledger act, as a separate Accept request records it. */
-export declare const ACCEPT_ACTION = "task accept-proof";
-/** Only a person's check stands between this result and done: its proof is short for that alone, and nobody accepted it. */
-export declare function personCheckPending(receipt: AssignmentReceipt | null): boolean;
-type Finished = {
-    ok: true;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-/** An acceptance this receipt owes before it finishes, by the result page's own rule: the person's own check
- * (no reason needed), or an exception a report that doesn't match its changes needs a reason for. Null when
- * Accept and finish is a plain completion: nothing is owed (no proof, a failed check, or a verified result),
- * or it was already accepted. */
-export declare function owedAcceptance(receipt: AssignmentReceipt | null, blockers?: readonly CompletionBlocker[]): "person-check" | "exception" | null;
-/** Accept and finish: the person's acceptance of the exact result they read and its completion, in one
- * transaction. Whether an acceptance is owed is decided here, against the receipt as it stands: only a
- * person's own check or a reasoned exception records one (with its ledger act); an exception without its
- * reason is refused; anything else is the plain completion Mark complete always was. The completion names the receipt the acceptance produced, under the
- * same digest a separate Accept then Mark complete leave. `receiptDigest` is the receipt as read, before
- * accepting (`runId`, when named, must be its run); any other change refuses both, and a refused completion
- * keeps no acceptance. `finish` completes the receipt (Mark complete by default; Complete and open a pull
- * request passes its own). */
-export declare function acceptAndCompleteAsOperator(store: Store, taskId: string, input: {
-    runId: number | null;
-    receiptDigest: string;
-    note: string | null;
-}, who: VerifiedApprover, now: Date, root?: string, finish?: (digest: string) => Finished): Finished;
-/** The ordinary worker reconciles at most 50 owned roots per pass, and skips a
- * pass when nothing moved (sweep-gate.ts). A lost wakeup is recovered after
- * restart; immutable notification keys dedupe it. */
-export declare function syncAssignmentHandoffs(store: Store, now: Date, repos: readonly string[], root?: string): void;
-/** The history of assignment handoffs sent to people (the `assignment-handoff` notifications), read by cursor. It is
- * not a delivery path: nothing is saved, replayed or acknowledged here. Leads receive their updates through the
- * assignment inbox (assignment-delivery.ts), the one road results take to a lead. */
-export declare function assignmentUpdates(store: Store, now: Date, access: AssignmentAccess, query: {
-    after: number;
-    limit: number;
-}, root?: string): {
-    events: {
-        id: number;
-        createdAt: string;
-        rootId: string;
-        digest: string;
-        superseded: boolean;
-        assignment: {
-            version: 1;
-            rootId: string;
-            activeTaskId: string;
-            state: "cancelled" | "checking" | "complete" | "needs-decision" | "ready-to-check" | "working";
-            detail: string;
-            owner: (AssignmentOwner & {
-                active: boolean;
-            }) | null;
-            primaryAction: WorkAction | null;
-            attention: string[];
-            attempts: number;
-            handoff: {
-                kind: "result" | "decision" | "attention";
-                digest: string;
-                acknowledged: boolean;
-            } | null;
-            completion: {
-                actor: string;
-                at: string;
-                digest: string;
-                lead?: true;
-                landed?: string;
-            } | null;
-            result: {
-                digest: string;
-                taskId: string;
-                runId: number;
-                base: string | null;
-                head: string | null;
-                completionKind: "accepted-exception" | "checked-build" | "finished-build" | "research-report" | "verified-build" | null;
-                checks: AssignmentChecks;
-                proofAcceptance: ProofAcceptanceRow | null;
-                verdict: "attested" | "refuted" | "short" | "verified" | null;
-                criteria: {
-                    passed: number;
-                    total: number;
-                };
-                evidence: "recorded";
-            } | null;
-            publication: {
-                state: string;
-                prUrl: string | null;
-                remoteState: string | null;
-            } | null;
-            review: BuildReviewView | null;
-            deployment: {
-                status: "not-recorded";
-            };
-            readiness: {
-                verdict: ProofVerdict | null;
-                checksOff: boolean;
-                blockers: CompletionBlocker[];
-            } | null;
-        };
-    }[];
-    nextCursor: number;
-    hasMore: boolean;
-};
-/** What a machine caller hears when the result owes a person's own check. */
-export declare const MACHINE_CANT_CHECK = "Only a person can say they checked this result. Open it in Toolroll and accept it there.";
-/** The terminal's accept, as the ledger keeps it: the exact request (run and receipt as read) and the receipt it made. */
-export declare const LOCAL_ACCEPT_ACTION = "task complete (local owner)";
-/** What the terminal's accept answers: done (or done already, by this same request), or why not. */
-export type LocalAcceptance = {
-    ok: true;
-    replayed: boolean;
-    accepted: "person-check" | "exception" | null;
-    assignment: AssignmentSnapshot;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-/**
- * The terminal's Accept (local-owner plan §3, slice 1): the laptop's local owner, with no password, accepts the exact
- * result its screen read (`runId` and `receiptDigest`, pinned when the screen opened) and completes it, in one
- * transaction. Never a password check: the owner is the one in flight now, acting as exactly `complete-task`, still
- * standing (local mode on at its generation, the account at its generation), and the approver is minted from that,
- * then re-proved by `acceptAndCompleteAsOperator`, which keeps every rule a completion has (exact receipt and run,
- * project access, slice 0's work rule, failed-check and protected-work blockers, rollback of the acceptance if the
- * completion is refused). What is owed decides what the request must carry: a person's own check needs `checked`, an
- * exception needs `reason` (already trimmed and validated by the command). The request and the receipt it produced are
- * recorded; the same request again answers "already" after re-proving the owner, and writes nothing.
- */
-export declare function completeAsLocalOwner(store: Store, taskId: string, input: {
-    runId: number;
-    receiptDigest: string;
-    checked: boolean;
-    reason: string | null;
-}, now: Date, root?: string): LocalAcceptance;
-export {};

package/dist/attest.d.ts

@@ -1,59 +0,0 @@
-/**
- * Tier-2 attestation (Parity II Phase 3, spec v1 D6 + v2 A2 + v3 B3 + v4 C3):
- * a provider outside tier 1 runs ONLY at versions its conformance fixtures
- * were proven against. The check is enforced at the one spawning gateway —
- * this module only states ranges and probes binaries; it spawns no agent.
- *
- * Guarantee, stated exactly (v4 C3): attestation proves the version of the
- * binary OBSERVED AT SPAWN TIME — probe and spawn share one resolved
- * absolute path, revalidated by a fresh stat immediately before use. A
- * concurrent atomic replacement between that stat and the kernel exec is
- * acknowledged as unprovable without content-addressed snapshots, and
- * nothing here claims otherwise.
- *
- * Re-attestation is a release act: run the conformance suite against the
- * new CLI, move `ceiling` in a reviewed commit. Removal criterion (ruling
- * 13's N, fixed): three consecutive minor releases failing conformance
- * without a fixable adapter change retire the adapter, typed.
- */
-import { type ProviderId } from "./provider.js";
-export type AttestationRange = {
-    /** Lowest plain release the fixtures cover, inclusive. */
-    floor: string;
-    /** First release the fixtures do NOT cover, exclusive. */
-    ceiling: string;
-    /** The exact version the current fixture set was recorded against. */
-    fixturesAt: string;
-};
-/** Tier-1 providers deliberately have NO entry: no probe, no new refusal —
- * their spawn road stays byte-identical (spec A2). */
-export declare const ATTESTATIONS: Partial<Record<ProviderId, AttestationRange>>;
-export declare function attestationOf(provider: ProviderId): AttestationRange | null;
-export type AttestOutcome = {
-    ok: true;
-    executable: string;
-    version: string;
-} | {
-    ok: false;
-    problem: string;
-    version: string | null;
-};
-export type VersionProbe = (file: string, args: readonly string[], timeoutMs: number) => Promise<{
-    code: number;
-    stdout: string;
-}>;
-export declare function versionInRange(version: string, range: AttestationRange): boolean;
-/** PATH resolution to ONE absolute realpath — the path the probe runs and
- * the path the gateway spawns (v3 B3: no second resolution). */
-export declare function resolveExecutable(binary: string): string | null;
-/** Tests only. */
-export declare function resetAttestationCache(): void;
-/**
- * The pre-spawn check (v2 A2): resolve, revalidate, probe if anything
- * moved, compare. Every failure is a typed refusal with words — never a
- * throw, never a silent pass. Returns null for tier-1 providers.
- */
-export declare function attestProvider(provider: ProviderId, binary: string, probe?: VersionProbe): Promise<AttestOutcome | null>;
-/** What the installed CLI says its version is, with no range attached: a recogniser's own check (exhaustion.ts), asked of
- * the exact executable PATH resolves on this runner, only when a terminal already reads as a plan limit. Null: no answer. */
-export declare function reportedVersion(binary: string, probe?: VersionProbe): Promise<string | null>;

package/dist/audit-cli.d.ts

@@ -1,17 +0,0 @@
-import type { RemoteRun } from "./remote-run.js";
-import { type AuditAction, type AuditReader } from "./remote-audit.js";
-import type { Store } from "./store.js";
-export declare const AUDIT_USAGE = "Use audit [--person <name>] [--token <name>] [--source api|mcp] [--since <days>d] [--limit <n>] [--cursor <id>] [--json].";
-type AuditContext = {
-    store: Store;
-    write: (s: string) => void;
-    json: boolean;
-    now: Date;
-    principal?: RemoteRun;
-};
-/** The reader a run is: the machine's owner locally, else the remote caller with their role and projects. */
-export declare function readerOf(store: Store, remote: RemoteRun | undefined): AuditReader;
-export declare function auditCommand(positional: readonly string[], flags: Map<string, string | true>, context: AuditContext): number;
-/** One line per action: outcome first, then who, token, source, what and where. */
-export declare function auditLine(action: AuditAction): string;
-export {};

package/dist/backend.d.ts

@@ -1,97 +0,0 @@
-/**
- * The contract every work graph is driven through, and the guard around it.
- *
- * §4's interface, with one deliberate omission: `hold` is not here. A hold is
- * an operational pause — "not tonight, we are waiting on a person" — and not a
- * claim about how the work is structured, so it lives in the overlay where it
- * costs nobody else's tracker anything. Dependency edges are the opposite, and
- * that asymmetry is the whole rule:
- *
- * **Scheduling edges are never emulated.** A backend with no native edges is
- * *ineligible for dependency scheduling*, not repaired with invisible ones. A
- * private graph is shadow data: teammates and other tools read a task as ready
- * while our overlay privately calls it blocked, and the divergence becomes
- * migration-critical the moment anybody wants out. So `addEdge` on a backend
- * whose edges are unverified refuses, and says why, rather than storing
- * something only we can see.
- *
- * Every method answers with an outcome rather than throwing. These call other
- * people's binaries over other people's networks; failure is a normal Tuesday,
- * and one unreachable backend must not end a run covering four others.
- */
-import { type Store, type TaskState } from "./store.js";
-import type { Deps } from "./graph.js";
-import type { ExecResult, RunOptions } from "./exec.js";
-export type Runner = (file: string, args: readonly string[], options?: RunOptions) => Promise<ExecResult>;
-/** What a backend can tell us about a task, in terms we share across all of them. */
-export type BackendTask = {
-    id: string;
-    title: string;
-    state: TaskState;
-};
-export type TaskSpec = {
-    title: string;
-    body?: string;
-};
-export type Outcome<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    reason: OutcomeReason;
-    message: string;
-};
-/**
- * `unsupported` is not a failure of this run — it is a permanent property of
- * the backend, and a caller should stop asking rather than retry.
- */
-export type OutcomeReason = "unsupported" | "denied" | "unreachable" | "unreadable" | "rejected";
-export interface GraphBackend {
-    readonly name: string;
-    /** Whether this backend carries dependency edges of its own. */
-    readonly deps: Deps;
-    listReady(): Promise<Outcome<BackendTask[]>>;
-    get(id: string): Promise<Outcome<BackendTask | null>>;
-    create(spec: TaskSpec): Promise<Outcome<string>>;
-    setState(id: string, state: TaskState): Promise<Outcome<void>>;
-    addEdge(blocked: string, blocker: string): Promise<Outcome<void>>;
-}
-export declare const ok: <T>(value: T) => Outcome<T>;
-export declare const no: (reason: OutcomeReason, message: string) => Outcome<never>;
-/**
- * The refusal a backend without confirmed edges gives, spelled once so every
- * adapter says the same thing and nobody is tempted to soften it.
- */
-export declare function edgesNotEmulated(name: string): Outcome<never>;
-/** Turn a failed command into words, without pretending to know more than we do. */
-export declare function describeFailure(result: ExecResult): string;
-export declare function parseJson(text: string): unknown | null;
-/**
- * The built-in store, behind the same contract as everyone else.
- *
- * Worth the wrapper even though it is ours: the scheduler should not be able
- * to tell which backend it is driving, and the day this is the only one with a
- * privileged shortcut is the day the interface stops being tested.
- *
- * It is the only backend here whose edges are both native and ours to write,
- * so it is also the only one where dependency scheduling is unconditionally
- * available.
- */
-export declare function builtIn(store: Store, now?: () => Date): GraphBackend;
-export type GuardOptions = {
-    store: Store;
-    repo: string;
-};
-/**
- * Wrap a backend so nothing can write through it without a grant.
- *
- * Applied once, at construction, rather than checked inside each adapter — an
- * authorization that every implementation has to remember to call is one that
- * a future adapter will forget, and it will forget it silently. Here the only
- * way to reach a mutating method is through the wrapper, and adding a backend
- * later inherits the check by construction.
- *
- * Reads pass straight through. Discovery has always been read-only and needs
- * no permission; it is writing to somebody else's tracker that requires one.
- */
-export declare function guarded(backend: GraphBackend, options: GuardOptions): GraphBackend;

package/dist/backup-ui.d.ts

@@ -1,32 +0,0 @@
-/**
- * Settings → Backups (sprint 8): how the last backup went and one button to
- * back up now, then the schedule, past backups and how to restore. Built from
- * the revamp kit (src/design/KIT.md); the Settings frame adds the title.
- */
-import { type Html } from "./html.js";
-import type { BackupRun, BackupSettings, LiveBackupState } from "./store.js";
-/** The schedules on offer and the most copies kept. Here rather than in backup.ts so the page never loads `node:sqlite`. */
-export declare const BACKUP_EVERY_HOURS: readonly [1, 6, 12, 24];
-/** The continuous copy's choices, in minutes (live-backup.ts LIVE_EVERY_MINUTES; here so the page never loads it). */
-export declare const LIVE_EVERY: readonly [1, 5, 15, 30];
-export declare const MAX_KEEP = 100;
-/** The page is kit pieces now; nothing of the old look is left. Kept as an export for the shared stylesheet. */
-export declare const BACKUP_CSS = "";
-export type BackupView = {
-    settings: BackupSettings;
-    folder: string;
-    defaultFolder: string;
-    runs: BackupRun[];
-    csrf: string;
-    now: Date;
-    /** The continuous copy (live-backup.ts): its settings, latest verified copy and folder. */
-    live?: {
-        state: LiveBackupState;
-        folder: string;
-        defaultFolder: string;
-    };
-};
-export declare function backupHtml(view: BackupView, said: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;