toolroll 0.9.103 → 0.9.105

package/dist/design/kit.d.ts

@@ -1,216 +0,0 @@
-/**
- * The revamp kit's words and rules, shared by the server's HTML kit (src/server/kit.ts) and the React kit
- * (src/browser/kit/), so both draw the same thing from the same facts. No DOM, no server state: the rules
- * are in src/design/KIT.md, the look in src/design/kit.css.
- *
- * The approval helpers here decide only what a page SHOWS (a password field, one click, or no button). The server
- * still proves every act at the moment it happens (scope.ts freshness, passwordless.ts, people-tokens.ts); a page
- * that shows one click for an act the server then refuses says so in place.
- */
-import { type Headline } from "../task-status.js";
-/** The five status words. */
-export type StatusKey = "needs" | "running" | "queued" | "finished" | "failed";
-/** A chip's tone: "" is neutral; "ask" names a specific ask inside a Needs-you group (ink words, ink dot). */
-export type ChipTone = "" | "needs" | "ask" | "live" | "done" | "failed";
-export declare const STATUS: Readonly<Record<StatusKey, {
-    word: string;
-    tone: ChipTone;
-}>>;
-/** A task's headline (task-status.ts) as the kit's chip: its own word, in the tone of the status it belongs to. A
- * row that waits on a person never shows a failure tone; something that waits on someone else never carries the needs-you mark. */
-export declare function chipOfHeadline(headline: Headline): {
-    word: string;
-    tone: ChipTone;
-    status: StatusKey;
-};
-/** Which of the five a headline is. */
-export declare function statusOfHeadline(headline: Headline): StatusKey;
-/** Resource states (a computer that builds, not work): never the needs-you mark. */
-export declare const RESOURCE: Readonly<Record<"idle" | "building" | "offline", {
-    word: string;
-    tone: ChipTone;
-}>>;
-/**
- * none = one click (answer, accept, retry, merge, remove a hold);
- * standard = a password unless Passwordless is on or a password was typed in the last 15 minutes here;
- * step-up = a password unless Passwordless is on;
- * way-in = anything that creates or widens a way in (invites, tokens, sign-in methods, widening access):
- *          always the password typed now.
- */
-export type ApprovalKind = "none" | "standard" | "step-up" | "way-in";
-export declare const APPROVAL_KINDS: readonly ApprovalKind[];
-/** The facts a page has about this person and act, as the server read them for this page. */
-export type ApprovalFacts = {
-    /** Passwordless is on for this signed-in browser (html.ts passwordlessRendering). */
-    passwordless: boolean;
-    /** A recently typed password would stand in for this act now (scope.ts freshnessFor preview): the act is allowlisted and
-     * the password was typed on this session within the window. Only a standard act honours it. */
-    remembered: boolean;
-    /** When the remembered password stops counting, as words ("10:47"), for the terms line. */
-    rememberedUntil?: string | null;
-    /** An automatic-approval rule covers this act: the page shows no button at all. Never for way-in. */
-    automatic?: boolean;
-};
-/** What the page shows: a password field, one click, or no button (approved automatically). */
-export type ApprovalAsk = "password" | "click" | "automatic";
-export declare function approvalAsk(kind: ApprovalKind, facts: ApprovalFacts): ApprovalAsk;
-/** How a click without a password is justified, for the record line after an approval. */
-export declare function approvalHow(kind: ApprovalKind, facts: ApprovalFacts): "password" | "remembered" | "passwordless" | "none" | "automatic";
-/** The terms line under an approval: which rule applies, in words. Empty for a one-click act. */
-export declare function termsOf(kind: ApprovalKind, facts: ApprovalFacts): string;
-/** A duration in seconds as the timing rows say it: "38s", "6m 12s", "1h 25m". */
-export declare function dur(seconds: number): string;
-/** "3 flows", "1 flow". */
-export declare const plural: (n: number, one: string, many: string) => string;
-/** A step's state on the timing axis. */
-export type TimingState = "ok" | "run" | "q" | "bad" | "wait";
-export declare const TIMING_WORDS: Readonly<Record<TimingState, string>>;
-export type TimingRow = {
-    name: string;
-    sub?: string;
-    st: TimingState;
-    start: number;
-    dur: number;
-};
-/** Each row's bar as percentages of one shared axis; a queued row has no bar until it starts. */
-export declare function timingBars(rows: readonly TimingRow[], scale?: number): Array<{
-    left: number;
-    width: number;
-} | null>;
-/** A step row's marker: done (an ink disc with a check), needs (waits on this person: an ink ring with a dot), live
- * (runs now: blue), wait (current, waiting on nothing this person does), stuck (stopped there: vermilion), skipped (a
- * dashed ring), todo (not reached: a grey ring). */
-export type StepRowMark = "done" | "needs" | "live" | "wait" | "stuck" | "skipped" | "todo";
-/** The words a screen reader hears for a step row's marker. */
-export declare const STEP_ROW_WORDS: Readonly<Record<StepRowMark, string>>;
-/** The id of a step row's body, for its disclosure's aria-controls. */
-export declare const stepRowBodyId: (key: string) => string;
-/** One step on a progress line: done (a check), now (waits on you: ink), live (running: blue), failed, or to do. */
-export type StepState = "done" | "now" | "live" | "failed" | "todo";
-export type StepItem = {
-    label: string;
-    state: StepState;
-    sub?: string;
-};
-/** The words a screen reader hears for a step's state. */
-export declare const STEP_WORDS: Readonly<Record<StepState, string>>;
-/** How far the line is filled, 0–1: up to the current step (the first that isn't done), or all of it. */
-export declare function stepsFill(steps: readonly StepItem[]): number;
-/** One shape of a 24×24 stroke icon: its element and attributes (data, so each side draws it with its own escaping). */
-export type IconShape = readonly ["path", {
-    readonly d: string;
-}] | readonly ["circle", {
-    readonly cx: number;
-    readonly cy: number;
-    readonly r: number;
-}] | readonly ["rect", {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-    readonly rx: number;
-}];
-/** The icons the kit draws (lucide shapes). */
-export declare const KIT_ICONS: {
-    readonly home: readonly [IconShape, IconShape];
-    readonly tasks: readonly [IconShape, IconShape, IconShape, IconShape, IconShape];
-    readonly flows: readonly [readonly ["rect", {
-        readonly x: 3;
-        readonly y: 3;
-        readonly width: 8;
-        readonly height: 8;
-        readonly rx: 2;
-    }], IconShape, readonly ["rect", {
-        readonly x: 13;
-        readonly y: 13;
-        readonly width: 8;
-        readonly height: 8;
-        readonly rx: 2;
-    }]];
-    readonly agents: readonly [IconShape, readonly ["rect", {
-        readonly x: 4;
-        readonly y: 8;
-        readonly width: 16;
-        readonly height: 12;
-        readonly rx: 2;
-    }], IconShape, IconShape, IconShape, IconShape];
-    readonly projects: readonly [IconShape];
-    readonly settings: readonly [IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape];
-    readonly pen: readonly [IconShape];
-    readonly arrow: readonly [IconShape, IconShape];
-    readonly plus: readonly [IconShape, IconShape];
-    readonly send: readonly [IconShape, IconShape];
-    readonly stop: readonly [readonly ["rect", {
-        readonly x: 6;
-        readonly y: 6;
-        readonly width: 12;
-        readonly height: 12;
-        readonly rx: 2;
-    }]];
-    readonly x: readonly [IconShape, IconShape];
-    readonly back: readonly [IconShape];
-    readonly menu: readonly [IconShape, IconShape, IconShape];
-    readonly search: readonly [IconShape, IconShape];
-    readonly chevron: readonly [IconShape];
-    readonly check: readonly [IconShape];
-    readonly alert: readonly [IconShape, IconShape, IconShape];
-    readonly more: readonly [IconShape, IconShape, IconShape];
-    readonly file: readonly [IconShape, IconShape];
-    readonly minus: readonly [IconShape];
-    readonly fit: readonly [IconShape, IconShape, IconShape, IconShape];
-    readonly bolt: readonly [IconShape];
-    readonly code: readonly [IconShape, IconShape];
-    readonly sun: readonly [IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape];
-    readonly cpu: readonly [readonly ["rect", {
-        readonly x: 4;
-        readonly y: 4;
-        readonly width: 16;
-        readonly height: 16;
-        readonly rx: 2;
-    }], readonly ["rect", {
-        readonly x: 9;
-        readonly y: 9;
-        readonly width: 6;
-        readonly height: 6;
-        readonly rx: 1;
-    }], IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape, IconShape];
-    readonly bell: readonly [IconShape, IconShape];
-    readonly shield: readonly [IconShape];
-    readonly folder: readonly [IconShape];
-    readonly people: readonly [IconShape, IconShape, IconShape, IconShape];
-    readonly coin: readonly [IconShape, IconShape, IconShape];
-    readonly monitor: readonly [readonly ["rect", {
-        readonly x: 2;
-        readonly y: 3;
-        readonly width: 20;
-        readonly height: 14;
-        readonly rx: 2;
-    }], IconShape, IconShape];
-    readonly list: readonly [IconShape, IconShape, IconShape, IconShape, IconShape, IconShape];
-    readonly board: readonly [readonly ["rect", {
-        readonly x: 3;
-        readonly y: 3;
-        readonly width: 18;
-        readonly height: 18;
-        readonly rx: 2;
-    }], IconShape, IconShape];
-    readonly panel: readonly [readonly ["rect", {
-        readonly x: 3;
-        readonly y: 3;
-        readonly width: 18;
-        readonly height: 18;
-        readonly rx: 2;
-    }], IconShape];
-};
-export type KitIcon = keyof typeof KIT_ICONS;
-/** The eight Settings groups, in order: [label, slug, href]. */
-export declare const SETTINGS_GROUPS: ReadonlyArray<readonly [label: string, slug: string, href: string]>;
-/** Each group's icon on the Settings overview (wave D). */
-export declare const SETTINGS_GROUP_ICONS: Readonly<Record<string, KitIcon>>;
-/** How a Settings row says what waits on this person: "1 item needs you", "2 items need you". */
-export declare const needsWords: (n: number) => string;
-/** The not-found page's default words. */
-export declare const NOT_FOUND: {
-    title: (path: string) => string;
-    text: string;
-};

package/dist/desktop-access.d.ts

@@ -1,28 +0,0 @@
-import { type ExecResult } from "./exec.js";
-export type DesktopProjectAccess = {
-    repo: string;
-    state: "ready" | "permission-needed" | "missing" | "unavailable" | "checking";
-    message: string;
-};
-export type DesktopAccessReport = {
-    version: 1;
-    controllerPid: number;
-    checkedAt: string;
-    request: string;
-    projects: DesktopProjectAccess[];
-};
-export declare function accessFailure(repo: string, code: unknown): DesktopProjectAccess;
-/** Probe only unique files we created, inside Git metadata, never tracked files.
- * Run in a bounded child of the real service, not the foreground shell. */
-export declare function probeDesktopProject(repo: string): DesktopProjectAccess;
-export declare function interpretAccessProbe(repo: string, result: ExecResult): DesktopProjectAccess;
-export declare function checkDesktopProjects(repos: readonly string[]): Promise<DesktopProjectAccess[]>;
-/** A receipt from an old worker or old project selection is never readiness. */
-export declare function currentDesktopAccess(report: DesktopAccessReport | null, supervisor: {
-    phase?: string;
-    controllerPid?: number | null;
-    updatedAt?: string;
-} | null, repos: readonly string[], request: string): {
-    verified: boolean;
-    projects: DesktopProjectAccess[];
-};

package/dist/desktop-bundle.d.ts

@@ -1,16 +0,0 @@
-export type DesktopBundle = {
-    path: string;
-    hash: string;
-    buildId: string;
-    version: string;
-    bundleId: string;
-    schemaVersion: number;
-    development: boolean;
-    providerBin: string;
-    recoveryProtocol?: number;
-};
-/** Hash the exact bundle, including executable modes; reject aliases inside
- * it so a checked file cannot secretly refer to mutable external code. */
-export declare function bundleHash(path: string): string;
-export declare function readDesktopBundle(path: string): DesktopBundle;
-export declare function verifyDesktopUpdateBundles(previous: DesktopBundle, candidate: DesktopBundle): Promise<void>;

package/dist/desktop-host.d.ts

@@ -1,54 +0,0 @@
-import { type ServiceDefinition, type SupervisorRunner } from "./daemon.js";
-import { type ContainmentPolicy } from "./containment.js";
-import type { Store } from "./store.js";
-export type DesktopConfig = {
-    version: 1;
-    databaseFile: string;
-    repos: string[];
-    port: number;
-    identity: string;
-    runnerName?: string;
-    containment?: ContainmentPolicy;
-    databaseInitialized?: boolean;
-};
-export declare function readDesktopConfig(stateDir: string): DesktopConfig;
-export declare function writeDesktopConfig(stateDir: string, config: DesktopConfig): void;
-export declare function addDesktopProjects(stateDir: string, store: Store, paths: string[], exact?: boolean): Promise<DesktopConfig>;
-export declare function loadOrCreateDesktopConfig(stateDir: string, isolated?: boolean): DesktopConfig;
-export declare function openDesktopStore(file: string): Store;
-export declare function openConfiguredDesktopStore(stateDir: string): Store;
-/** Recovery controls must not depend on opening or migrating the task store. */
-export declare function desktopDatabaseStatus(file: string): {
-    ready: boolean;
-    message: string;
-    expectedSchema: number;
-};
-/** Share `up`'s existing durable credential, without replacing another login. */
-export declare function pairDesktopLogin(store: Store, file: string, login: {
-    name: string;
-    password: string;
-}): void;
-/** The desktop service definition the shell asks for: the shared launchd contract, labelled by the shell. */
-export declare function desktopServiceDefinition(stateDir: string, args: {
-    node: string;
-    helper: string;
-    label: string;
-    home?: string;
-    providerBin?: string;
-    containment?: ContainmentPolicy;
-    bundleId?: string;
-    buildId?: string;
-}): ServiceDefinition;
-export type DesktopLiveness = {
-    alive: true;
-    port: number;
-} | {
-    alive: false;
-    port: number;
-    problem: string;
-};
-/** The fresh-liveness check: the controller answers its identity challenge on the configured port. */
-export declare function verifyDesktopLiveness(config: DesktopConfig, fetchImpl?: typeof fetch): Promise<DesktopLiveness>;
-/** `service-start | service-stop | service-status --node <path> --helper <path> --label <label>`: the shell's service verbs, on the shared lifecycle. */
-export declare function desktopServiceCommand(verb: string, stateDir: string, config: DesktopConfig, argv: string[], supervise?: SupervisorRunner): Promise<Record<string, unknown>>;
-export declare function desktopMain(argv: string[], supervise?: SupervisorRunner): Promise<void>;

package/dist/desktop-update-gate.d.ts

@@ -1,12 +0,0 @@
-import type { Database } from "./store.js";
-export declare const UPDATE_PAUSED = "Toolroll is updating. Current work can finish; new work will resume after the update. Open Update status in the desktop app.";
-/** SQLite enforces the gate even for a CLI racing an old in-memory snapshot.
- * Existing leases, replies, heartbeats and task data remain writable. */
-export declare function installUpdateGate(db: Database, id: string): void;
-export declare function removeUpdateGate(db: Database, id: string): void;
-export declare function updateAdmissionPaused(db: Database): boolean;
-export declare function updateGateOwned(db: Database, id: string): boolean;
-export declare function activeUpdateWork(db: Database): Record<string, number>;
-/** Last admission race closes in the same SQLite write transaction as the
- * empty-work check. Existing work is never killed to satisfy an update. */
-export declare function freezeUpdateGate(db: Database, id: string): boolean;

package/dist/desktop-update-recovery.d.ts

@@ -1,14 +0,0 @@
-import { type ServiceDefinition, type SupervisorRunner } from "./daemon.js";
-import { type UpdateJournal } from "./desktop-update.js";
-export declare function updateRecoveryDefinition(j: UpdateJournal, home?: string): ServiceDefinition;
-export declare function armUpdateRecovery(stateDir: string, retry?: boolean, supervise?: SupervisorRunner, home?: string): Promise<void>;
-export type RecoveryHooks = {
-    attempt?: (j: UpdateJournal, signal: AbortSignal, onPid: (pid: number | null) => void) => Promise<void>;
-    cleanup?: (j: UpdateJournal) => Promise<void>;
-    sleep?: (ms: number) => Promise<void>;
-    pollMs?: number;
-    staleMs?: number;
-    receiptDir?: string;
-};
-export declare function runUpdateAttempt(j: UpdateJournal, signal: AbortSignal, onPid: (pid: number | null) => void, hooks?: RecoveryHooks): Promise<void>;
-export declare function superviseDesktopUpdate(stateDir: string, id: string, signal: AbortSignal, hooks?: RecoveryHooks): Promise<void>;

package/dist/desktop-update.d.ts

@@ -1,147 +0,0 @@
-import type { DatabaseSync } from "node:sqlite";
-import { type DesktopBundle } from "./desktop-bundle.js";
-import { type DesktopUpdateJournal, type DesktopUpdatePhase } from "./contracts/update-journal.js";
-type Phase = DesktopUpdatePhase;
-/** The update's journal (`desktop-update.json`, and `receipt.json` in its folder): src/contracts/update-journal.ts. */
-export type UpdateJournal = DesktopUpdateJournal;
-type ServiceState = {
-    state: string;
-    stale?: boolean;
-};
-export type UpdateHooks = {
-    verify?: (old: DesktopBundle, next: DesktopBundle) => Promise<void>;
-    serviceStatus?: (bundle: DesktopBundle, journal: Pick<UpdateJournal, "stateDir" | "label">) => Promise<ServiceState>;
-    service?: (action: "start" | "stop", bundle: DesktopBundle, journal: UpdateJournal) => Promise<void>;
-    healthy?: (bundle: DesktopBundle, journal: UpdateJournal, since: string) => Promise<boolean>;
-    swap?: (journal: UpdateJournal) => Promise<void>;
-    sleep?: (ms: number) => Promise<void>;
-    /** The clock the drain's two-minute limit reads (tests). */
-    now?: () => Date;
-    healthTimeoutMs?: number;
-    /** Fault injection for state-machine tests, never selectable by a CLI flag. */
-    checkpoint?: (phase: Phase) => void;
-    otherControllers?: (bundle: DesktopBundle, stateDir: string) => Promise<boolean>;
-    /** Whether a recorded service process still runs (tests). */
-    processAlive?: (pid: number) => boolean;
-};
-export declare const updateTerminal: (phase: string) => boolean;
-/** Durable receipts are private and independent of the app being replaced. */
-export declare function durableJson(file: string, value: unknown): void;
-export declare function readUpdateJournal(stateDir: string, retainedReceipt?: string): UpdateJournal | null;
-/** Which settled schema versions a caller works on: the desktop update, which never migrates, only this build's own. */
-export type SchemaAccepted = (version: number | null) => boolean;
-/** A finished run whose end Toolroll cannot show yet: in plain words, with the one command that clears it when a
- * person can. */
-export type LingeringRun = {
-    run: number;
-    on: string;
-    action: string | null;
-};
-/** How long an update waits on a finished run it cannot show has ended before it stops waiting and says why. */
-export declare const LINGERING_LIMIT_MS = 120000;
-export declare function lingeringRun(db: DatabaseSync): LingeringRun | null;
-export declare function lingeringWork(db: DatabaseSync): string | null;
-export declare const lingeringWords: (l: LingeringRun) => string;
-/** What an update says when it stops waiting on `l`: what is in the way, the command, and that new work resumed. */
-export declare const stoppedWaitingWords: (l: LingeringRun) => string;
-/** The next step once an update has stopped on `l`. */
-export declare const clearWords: (l: LingeringRun) => string;
-/** An update that is waiting or stopped, what on, and the one action that clears it: for `toolroll status` and the
- * console. `app`: the desktop app's update rather than `toolroll update`. */
-export type UpdateWaiting = {
-    app: boolean;
-    version: string;
-    stopped: boolean;
-    run: number | null;
-    on: string;
-    action: string | null;
-    words: string;
-    short: string;
-};
-export declare function updateWaitingWords(o: {
-    app: boolean;
-    version: string;
-    stopped: boolean;
-    lingering: LingeringRun | null;
-}): UpdateWaiting;
-/** An app updater that ended while letting work finish, with no automatic recovery coming to resume it, leaves new
- * work paused with nobody left to lift the pause. Nothing was stopped or swapped yet, so the pause is lifted here and
- * the update says it stopped. Returns what it said, or null. */
-export declare function releaseStalledDesktopUpdate(stateDir: string): string | null;
-/** The desktop app's update, when it is waiting on work in `databaseFile`'s installation, or stopped on a run still in
- * the way. An app updater that ended mid-drain is released first, as `toolroll update`'s is. */
-export declare function desktopUpdateWaitingOf(databaseFile: string, inTheWay: (run: number) => boolean, stateDirs?: readonly string[]): UpdateWaiting | null;
-/** The same settling reconcile the background worker runs: a finished run's leftover record of a process that never
- * started settles once the run's process groups are proven gone. A record nothing can prove either way stays. */
-export declare function settleLeftoverRecords(db: DatabaseSync, now: Date): number;
-/** Store.stopQuiescenceProblem's reasons, said for a person: no internal terms. Nobody vouches that a run stopped:
- * Toolroll proves it itself (stop-proof.ts), and `toolroll run settle` only has it look again now. */
-export declare function plainLingering(fallbackRun: number, problem: string): LingeringRun;
-export declare function previewDesktopUpdate(stateDir: string, installed: string, candidate: string, label: string, hooks?: UpdateHooks): Promise<{
-    old: DesktopBundle;
-    next: DesktopBundle;
-    configHash: string;
-    label: string;
-    stateDir: string;
-    databaseFile: string;
-    codingCatalogExpected: boolean;
-    wasRunning: boolean;
-    digest: string;
-    active: Record<string, number>;
-    message: string;
-}>;
-export declare function prepareDesktopUpdate(stateDir: string, installed: string, candidate: string, label: string, expected: string, hooks?: UpdateHooks): Promise<UpdateJournal>;
-export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
-/** Whether another process holds the lock in `file`, without making the file or changing it: a status read (a page
- * shows it, docs/plans/get-side-effects.md). A file that isn't there yet is held by nobody. */
-export declare function lockHeld(file: string): boolean;
-export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
-export declare function desktopUpdateStatus(stateDir: string): {
-    active: boolean;
-    phase: string;
-    detail: string;
-    running: boolean;
-    canResume: boolean;
-    canCancel: boolean;
-    error?: never;
-    automaticRecovery?: never;
-    recoveryAttempts?: never;
-    recoveryRepairs?: never;
-    wasRunning?: never;
-    backupPath?: never;
-    updateId?: never;
-    version?: never;
-    buildId?: never;
-    workDir?: never;
-} | {
-    active: boolean;
-    phase: "backing-up" | "cancelled" | "complete" | "draining" | "installing" | "needs-attention" | "prepared" | "releasing" | "restored" | "rolling-back" | "stopping" | "verifying";
-    detail: string;
-    error: string | null;
-    running: boolean;
-    automaticRecovery: boolean;
-    recoveryAttempts: number;
-    recoveryRepairs: number;
-    canResume: boolean;
-    canCancel: boolean;
-    wasRunning: boolean;
-    backupPath: string | null;
-    updateId: string;
-    version: string;
-    buildId: string;
-    workDir: string;
-};
-export declare function updateStopRequested(j: UpdateJournal): boolean;
-export declare function requestUpdateStop(stateDir: string): void;
-export declare function requestUpdateRestore(stateDir: string): void;
-export declare function launchDesktopUpdate(stateDir: string, retry?: boolean): Promise<void>;
-export declare function pauseUpdateRecovery(stateDir: string, id: string, detail: string): void;
-/** A private, verified copy of the task database, made under a write
- * reservation so no writer slips in between the snapshot and the copy. The
- * copy drops the update's own admission pause. `inside` runs before the
- * reservation is released, `after` once it is; returns the copy's hash. */
-export declare function verifiedDatabaseBackup(databaseFile: string, backupPath: string, gateId: string, inside?: () => Promise<void>, after?: () => void, accepts?: SchemaAccepted): Promise<string>;
-/** A SQLite OS lock releases on updater death. Each irreversible step has a
- * preceding durable intent; recovery determines the actual side by hashes. */
-export declare function runDesktopUpdate(stateDir: string, hooks?: UpdateHooks): Promise<void>;
-export {};

package/dist/digest-times.d.ts

@@ -1,3 +0,0 @@
-/** The evening digest choices Settings offers: off, or an evening hour — plus a time set from the command line,
- * kept as chosen. Shared by the console page and its no-script fallback. */
-export declare function digestTimes(current: string | null): [string, string][];

package/dist/disclosure.d.ts

@@ -1,6 +0,0 @@
-/** One disclosure glyph everywhere: the chevron. It points right while a fold is shut and turns down when it opens,
- * on the server pages, the enhanced folds (workspace-motion.ts) and the React views (lucide's ChevronRight). Every
- * other marker (the native triangle, ▸/▾, +/−, ⌄ and the old arrows) is turned off here, last, so no page can bring
- * a second glyph back. A summary that carries its own icon keeps it. Drawn with two borders: the page's content
- * policy allows no image, not even a data: one. */
-export declare const DISCLOSURE_CSS: string;

package/dist/discord-api.d.ts

@@ -1,24 +0,0 @@
-import { ChatDeliveryError, type ChatIdentity } from "./chat-delivery-state.js";
-import { chatObject as object } from "./chat-delivery.js";
-export { object };
-export declare const discordId: (v: unknown) => v is string;
-export type DiscordCredentials = ChatIdentity & {
-    botToken: string;
-};
-export type DiscordApi = (method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE", path: string, body?: Record<string, unknown>, file?: {
-    bytes: Uint8Array;
-    name: string;
-}) => Promise<Record<string, unknown>>;
-export declare class DiscordError extends ChatDeliveryError {
-}
-/** Discord's 403: the bot may not do this here (for a file, no Attach Files permission). */
-export declare const DISCORD_REFUSED = "Discord refused access. Check the app and direct-message permissions.";
-/** Discord's 404: the message (or the conversation) is gone. */
-export declare const DISCORD_GONE = "The Discord message or conversation is unavailable. Open the saved chat.";
-export declare function discordApi(token: string, fetcher?: typeof fetch): DiscordApi;
-export declare const discordCredentialFile: (dir: string) => string;
-export declare function loadDiscordCredentials(dir: string): DiscordCredentials | null;
-export declare function saveDiscordCredentials(dir: string, value: DiscordCredentials): void;
-export declare function clearDiscordCredentials(dir: string): void;
-export declare function checkDiscordCredentials(botToken: string, fetcher?: typeof fetch): Promise<DiscordCredentials>;
-export declare function discordMember(api: DiscordApi, member: string, channel: string): Promise<boolean>;

package/dist/discord-chat.d.ts

@@ -1,27 +0,0 @@
-import { ChatState, type ChatIdentity, type ChatEvent } from "./chat-delivery-state.js";
-import { type ChatDeliveryOptions } from "./chat-delivery.js";
-import { discordPlain } from "./reply-shape.js";
-import { type ChatAckHooks, type ChatLiveTransport, type LiveReplies } from "./chat-live.js";
-import { type DiscordApi } from "./discord-api.js";
-export type DiscordChatOptions = Omit<ChatDeliveryOptions, "state" | "label" | "member" | "partSize" | "maxProposal" | "live"> & {
-    api: DiscordApi; /** The live "Working on it…" message (chat-live.ts): on in the worker. */
-    liveReplies?: LiveReplies;
-};
-export declare const discordDelivery: (options: DiscordChatOptions) => ChatDeliveryOptions;
-export declare const processDiscordEvent: (options: DiscordChatOptions) => Promise<boolean>;
-export declare const planDiscordRooms: (options: DiscordChatOptions) => Promise<void>;
-export declare const planDiscordNotifications: (options: DiscordChatOptions) => Promise<void>;
-/** Save only normalized input. Interaction credentials and pairing codes never enter SQLite. */
-export declare function receiveDiscord(state: ChatState, identity: ChatIdentity, type: string, raw: unknown, now: Date): boolean;
-/** Escape Discord's presentation syntax; allowed_mentions also prevents actual pings. */
-export { discordPlain };
-export declare function discordCard(text: string, buttons?: Record<string, unknown>[], voice?: boolean): Record<string, unknown>;
-export declare function deliverDiscordPart(options: DiscordChatOptions): Promise<boolean>;
-/** The lead's words as Discord carries them, already rendered: one embed description (cut to its 4 096), empty
- * content, its buttons (none on a live message) and never a ping. Every field is sent on every edit: Discord keeps
- * what an edit leaves out, and inherits no allowed_mentions. */
-export declare function discordVoicePayload(rendered: string, buttons?: Record<string, unknown>[]): Record<string, unknown>;
-/** The live message for one owner message: a reply to it, created under a nonce so a repeat returns the same one. */
-export declare function discordLive(options: Pick<DiscordChatOptions, "api" | "identity">, event: ChatEvent, spacingMs?: number): ChatLiveTransport;
-/** The 👀 on the owner's message, and taking it off. A missing permission is asked about at most once a minute, quietly. */
-export declare function discordAckHooks(options: Pick<DiscordChatOptions, "api">): ChatAckHooks;

package/dist/discord-settings.d.ts

@@ -1,4 +0,0 @@
-import type { Store } from "./store.js";
-import { type Html } from "./html.js";
-import { type ChatSettingsOptions } from "./chat-settings-page.js";
-export declare function discordSettingsHtml(store: Store, dir: string, options?: ChatSettingsOptions): Html;

package/dist/discord.d.ts

@@ -1,10 +0,0 @@
-import { type DiscordChatOptions } from "./discord-chat.js";
-export declare function discordReadyMatches(raw: unknown, identity: {
-    app: string;
-    bot: string;
-}): boolean;
-export declare function followDiscord(options: Omit<DiscordChatOptions, "identity" | "api" | "owner" | "current"> & {
-    dir: string;
-    signal: AbortSignal;
-    notifications: () => boolean;
-}): Promise<void>;

package/dist/discover.d.ts

@@ -1,75 +0,0 @@
-/**
- * Reading the state of repositories.
- *
- * Every git invocation here is a read, and every one is prefixed with
- * `--no-optional-locks` — Toolroll scans repositories the operator may be
- * working in right now, and a discovery pass must never contend for the index
- * lock with their editor.
- *
- * Nothing raises. A repository that cannot be read comes back as a snapshot
- * carrying a named problem, because the alternative is a scan of forty repos
- * ending on the one that is broken.
- *
- * The reads are deliberately unequal in cost, and that shapes the module.
- * Listing refs, worktrees and the remote is O(refs) and lands in tens of
- * milliseconds. Computing ahead/behind walks history per branch — measured at
- * 22s on a cold 304MB repo — so it is bounded and degrades to a branch list
- * without it. Reading the working tree is O(working tree), measured at over
- * two minutes, so it does not happen at all unless asked for.
- */
-import { type ExecResult, type RunOptions } from "./exec.js";
-import { type Branch, type Worktree } from "./git.js";
-import { type ScanOptions } from "./scan.js";
-export type RepoSnapshot = {
-    path: string;
-    name: string;
-    /** Current branch, or null in detached HEAD. */
-    head: string | null;
-    remoteUrl: string | null;
-    branches: Branch[];
-    worktrees: Worktree[];
-    /** Uncommitted files, or null when the working tree was not read. */
-    dirtyFiles: number | null;
-    /**
-     * Whether ahead/behind could be computed. False means every branch carries a
-     * zeroed track, which is absence of data and not evidence of being in sync —
-     * a distinction the report has to respect or it hides the whole repository.
-     */
-    hasTracking: boolean;
-    /** What could not be read, in words. Never silently dropped. */
-    problems: string[];
-};
-export type Runner = (file: string, args: readonly string[], options?: RunOptions) => Promise<ExecResult>;
-export type InspectOptions = {
-    runner?: Runner;
-    /** Read the working tree for uncommitted changes. Off by default: see above. */
-    dirty?: boolean;
-};
-export type DiscoverOptions = InspectOptions & {
-    scan?: ScanOptions;
-    concurrency?: number;
-};
-/** Enough to keep git busy without turning a laptop fan on. */
-export declare const DEFAULT_CONCURRENCY = 8;
-/** Ref reads land in tens of milliseconds; seconds here means something is wrong. */
-export declare const REF_TIMEOUT_MS = 5000;
-/**
- * Ahead/behind is worth waiting for, since it is the signal itself. Ten
- * seconds because a 59MB repo with 18 branches and no commit-graph measured
- * 7.5s cold — just over a five second bound, which is the worst place for a
- * limit to sit.
- */
-export declare const TRACK_TIMEOUT_MS = 10000;
-/** The working tree is unbounded, so the bound has to be ours. */
-export declare const STATUS_TIMEOUT_MS = 10000;
-export declare function inspectRepo(path: string, options?: InspectOptions): Promise<RepoSnapshot>;
-/**
- * Inspect known repositories, skipping the walk entirely. Enrolled paths are
- * already the answer to "which repositories" — searching for them again would
- * be the tool distrusting a list the operator wrote down.
- */
-export declare function inspectAll(paths: readonly string[], options?: InspectOptions & {
-    concurrency?: number;
-}): Promise<RepoSnapshot[]>;
-/** Every repository at or below `roots`, inspected with bounded concurrency. */
-export declare function discover(roots: readonly string[], options?: DiscoverOptions): Promise<RepoSnapshot[]>;