toolroll 0.9.103 → 0.9.105

package/dist/tool-secret-store.d.ts

@@ -1,167 +0,0 @@
-export type SecretStoreKind = "macos-keychain" | "secret-service" | "files";
-/** One item's address: what the store lists, never a secret (a folder's or project's hash, a tool's name). */
-export type SecretItem = {
-    service: string;
-    account: string;
-};
-export type SecretBackend = {
-    kind: Exclude<SecretStoreKind, "files">;
-    /** Values are [A-Za-z0-9._-] only, at most `limit` characters. */
-    limit: number;
-    get(item: SecretItem): string | null;
-    /** `create`: only when no item is there yet ("exists" when one is). */
-    set(item: SecretItem, value: string, options?: {
-        create?: boolean;
-    }): "ok" | "exists";
-    remove(item: SecretItem): void;
-};
-export declare class SecretStoreError extends Error {
-}
-/** The words Settings and `toolroll integrations` use for where secrets rest. */
-export declare const STORE_WORDS: Readonly<Record<SecretStoreKind, string>>;
-/** Said instead when a keyring is installed but doesn't answer, so files are all there is. */
-export declare const UNANSWERED_WORDS = "Secrets are protected by owner-only files on this computer: its keyring isn't answering.";
-/** The macOS Keychain, through `security -i` (`keychain`: a keychain file instead of the user's own, for tests). */
-export declare function macosKeychain(options?: {
-    keychain?: string;
-    binary?: string;
-}): SecretBackend;
-/** The Secret Service (GNOME Keyring, KWallet), through `secret-tool` at `binary`, an absolute path; the value goes on its stdin. */
-export declare function secretService(options: {
-    binary: string;
-}): SecretBackend;
-/**
- * `path` when it is a program only the system (or, for a test's stand-in, one of `owners`) can have put there: a real
- * executable file nobody else can change, in folders nobody else can either. Null otherwise.
- */
-export declare function trustedProgram(path: string, owners?: readonly number[]): string | null;
-/** Where `secret-tool` may be: the system's own folders, never the PATH a process was given. */
-export declare const SECRET_TOOL_PATHS: readonly string[];
-/** This computer's store as found: a backend, or none, and when none, whether one is installed but not answering. */
-export type DetectedStore = {
-    backend: SecretBackend | null;
-    unanswered: boolean;
-};
-/**
- * Find this computer's store: the macOS Keychain where the system's `security` is; a Secret Service where the system's
- * `secret-tool` is and answers; else none (files). A `secret-tool` that is there but can't reach a keyring (no session
- * bus) is none too, and says so.
- */
-export declare function detectSecretStore(options?: {
-    platform?: NodeJS.Platform;
-    secretTools?: readonly string[];
-    owners?: readonly number[];
-}): DetectedStore;
-/** Tests choose the store (a keychain file of their own, files, or what detection found); null goes back to this computer's. */
-export declare function chooseSecretStore(store: SecretBackend | "files" | DetectedStore | null): void;
-/** This computer's store (found once), or null for owner-only files. */
-export declare function secretBackend(env?: NodeJS.ProcessEnv): SecretBackend | null;
-/** Where secrets rest, in the words Settings and `toolroll integrations` share; `problem` when Toolroll's folder can't be used. */
-export declare function secretStorage(): {
-    kind: SecretStoreKind;
-    words: string;
-    filesOnly: boolean;
-    problem?: string;
-};
-/** The text stored at `item`, or null when nothing is. A head read while a writer replaces it is read again. */
-export declare function readValue(backend: SecretBackend, item: SecretItem): string | null;
-/**
- * Store `text` at `item`: the chunks of a new generation first, then the head that names them, then the old
- * generation's chunks are removed. `create`: only when nothing is stored there yet.
- */
-export declare function writeValue(backend: SecretBackend, item: SecretItem, text: string, options?: {
-    create?: boolean;
-}): "ok" | "exists";
-/** Remove what is stored at `item`, every chunk with it. */
-export declare function removeValue(backend: SecretBackend, item: SecretItem): void;
-/** The folder's name, beside the database. */
-export declare const SECRET_FOLDER = "tool-secrets";
-/** Where Toolroll records which sealing key it made: the database, which no build can write. */
-export type KeyAnchor = {
-    read(): string | null;
-    swap(expected: string | null, next: string): boolean;
-};
-/** An anchor kept in this process alone: a test's own folder. */
-export declare function memoryAnchor(): KeyAnchor;
-/** Toolroll's folder for secrets, checked: its key in hand, and where the files kept before it are (`legacy`). */
-export type SecretFolder = {
-    readonly root: string;
-    readonly dir: string;
-    readonly legacy: string | null;
-    dev: number;
-    ino: number;
-    key: Buffer;
-    digest: string;
-    anchor: KeyAnchor;
-};
-/**
- * Prepare Toolroll's folder for secrets beside `stateDir` (the folder holding the database), checked against what
- * `anchor` recorded: made with its sealing key when it isn't there yet (`create`), refused when something else put a
- * folder, key or link there. `standing`: the folder this process uses by default (Toolroll's own start).
- */
-export declare function prepareSecretFolder(stateDir: string, anchor: KeyAnchor, options?: {
-    create?: boolean;
-    legacy?: string | null;
-    standing?: boolean;
-}): {
-    ok: true;
-    dir: string;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * Name Toolroll's folder for secrets (beside `stateDir`, the database's folder) and the record to check it against,
- * without touching it yet: it is prepared the first time a secret is used. `standing`: this process's default.
- */
-export declare function registerSecretFolder(stateDir: string, anchor: KeyAnchor, options?: {
-    legacy?: string | null;
-}): void;
-/**
- * Toolroll's folder for secrets, checked again now: the one prepared at start when `state` is absent, else the one
- * beside `state` (a test's own folder is prepared the first time it is used, against an anchor in this process).
- */
-export declare function secretFolder(state?: string): SecretFolder;
-/** Forget every prepared folder (tests). */
-export declare function forgetSecretFolders(): void;
-/** The keychain service for everything kept for this folder's Toolroll: its folder, hashed. Never a secret. */
-export declare const serviceOf: (folder: SecretFolder) => string;
-/**
- * A path inside `base` (the folder, or Toolroll's own folder above it), each folder on the way checked: a real folder
- * of this user's that nobody else can write, never a link. Made owner-only when `make` (else a missing one ends the
- * walk: nothing is there).
- */
-export declare function pathIn(base: string, parts: readonly string[], options?: {
-    make?: boolean;
-}): string;
-/** A file's text, read without following a link; null when there is none. Anything not plainly Toolroll's is refused. */
-export declare function readOwnFile(path: string): string | null;
-/** Write a file whole and owner-only: a new file beside it, then renamed over it, so a link or second name planted there is replaced, never written through. */
-export declare function writeOwnFile(path: string, text: string): void;
-/** A file's bytes overwritten, then the file removed (a link is only removed, never followed). */
-export declare function destroyOwnFile(path: string): void;
-/** One change at a time to what `name` keeps, across Toolroll's processes (a lock file in the folder), re-entrant within one. */
-export declare function withSecretLock<T>(folder: SecretFolder, name: string, work: () => T): T;
-/** The same, for work that waits on the network (renewing a sign-in): other processes wait for it, up to `waitMs`. */
-export declare function withSecretLockAsync<T>(folder: SecretFolder, name: string, work: () => Promise<T>, options?: {
-    staleMs?: number;
-    waitMs?: number;
-}): Promise<T>;
-/** `text` sealed for `item` with the folder's key. */
-export declare function seal(text: string, item: SecretItem, folder: SecretFolder): string;
-/** What `seal` sealed for `item`; refused when it was sealed for another item, with another key, or changed. */
-export declare function unseal(sealed: string, item: SecretItem, folder: SecretFolder): string;
-/** The sealed text kept at `item`, opened; null when nothing is. */
-export declare function readSealed(backend: SecretBackend, folder: SecretFolder, item: SecretItem): string | null;
-/** Keep `text` at `item`, sealed. */
-export declare function writeSealed(backend: SecretBackend, folder: SecretFolder, item: SecretItem, text: string, options?: {
-    create?: boolean;
-}): "ok" | "exists";
-/**
- * A secret Toolroll holds for an integration, by `name` ("linear-key", "google-mail", "flow-hook.12"), for the
- * Toolroll whose folder is `state`. `file` (inside `state`) is where it was kept before, and still is where there's no
- * keychain. The first read or write with a keychain moves the file in.
- */
-export declare function readHeldSecret(state: string, name: string, file: readonly string[]): string | null;
-/** Keep (or, with null, remove) a held secret: see readHeldSecret. */
-export declare function writeHeldSecret(state: string, name: string, file: readonly string[], value: string | null): void;

package/dist/toolroll-update-cli.d.ts

@@ -1,15 +0,0 @@
-import { installMethod } from "./install-method.js";
-import { type RuntimeRef, type UpdateSystem } from "./toolroll-update.js";
-export declare const UPDATE_HELP = "toolroll update                 preview updating to the latest release\ntoolroll update --yes           update: verify, let running work finish, back up, rehearse, switch, restart, check\n  --version X                   a specific release instead of the latest\n  --when-idle                   pause new work and wait for running work (the default)\n  --now                         refuse if any work is running\n  --at HH:MM                    wait until then (e.g. --at 03:00)\n  --allow-downgrade             with --version, go back to an older release\ntoolroll update --rollback [--yes]   return to the previous version and its database backup\ntoolroll update --status | --resume | --cancel";
-export type UpdateCliDeps = {
-    system?: UpdateSystem;
-    current?: RuntimeRef;
-    method?: ReturnType<typeof installMethod>;
-    latest?: () => Promise<{
-        version: string;
-    }>;
-    databaseFile?: string;
-    /** Where the console's one-off update job's definition lives (tests). */
-    home?: string;
-};
-export declare function runUpdateCommand(args: readonly string[], write: (line: string) => void, deps?: UpdateCliDeps): Promise<number>;

package/dist/toolroll-update-ui.d.ts

@@ -1,47 +0,0 @@
-/**
- * Settings → Updates: the installed version, one of three ways to update
- * (behind the operator's password), the update's steps live while it runs,
- * and a one-time "What's new" section afterwards. The work itself is the
- * `toolroll update` command (toolroll-update.ts), started as its own job.
- * Built from the revamp kit; the Settings frame adds the title.
- */
-import { type Html } from "./html.js";
-import type { InstallMethod } from "./install-method.js";
-import { type RuntimeUpdateJournal } from "./toolroll-update.js";
-/** The page is kit pieces now; nothing of the old look is left. Kept as an export for the shared stylesheet. */
-export declare const UPDATES_CSS = "";
-export type UpdatesView = {
-    current: string;
-    /** The newest release, why it is unknown, or not asked because update checks are off. */
-    latest: {
-        version: string;
-    } | {
-        problem: string;
-    } | {
-        off: true;
-    } | {
-        pending: true;
-    };
-    method: InstallMethod;
-    journal: RuntimeUpdateJournal | null;
-    running: boolean;
-    whatsNew: {
-        version: string;
-        notes: string[];
-    } | null;
-    /** The version `toolroll update --rollback` returns to: the last completed update's, while it is what runs. */
-    rollbackTo: string | null;
-    csrf: string;
-};
-/** The steps, each done, current, failed or waiting. Also the live region's fragment. */
-export declare function updateStepsHtml(j: RuntimeUpdateJournal, running: boolean, options?: {
-    title?: boolean;
-}): Html;
-export declare function updatesHtml(view: UpdatesView, said: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;
-export declare function newerThan(a: string, b: string): boolean;
-/** Polls the steps every two seconds, keeps trying while the console
- * restarts, and reloads once the update has finished. */
-export declare function updatesScript(): string;

package/dist/toolroll-update.d.ts

@@ -1,265 +0,0 @@
-import type { DatabaseSync } from "node:sqlite";
-import { type UpdateWaiting } from "./desktop-update.js";
-import { type SupervisorRunner } from "./daemon.js";
-import { type ProcessProbe } from "./runner-process.js";
-import { RUNTIME_PHASES, type RuntimeUpdateJournalRecord } from "./contracts/update-journal.js";
-export declare const PROVENANCE_REPOSITORY = "https://github.com/ap9000/toolroll";
-export declare const PROVENANCE_WORKFLOW = ".github/workflows/publish.yml";
-export declare const PROVENANCE_ISSUER = "https://token.actions.githubusercontent.com";
-/** The steps a person sees, in order. */
-export declare const UPDATE_STEPS: readonly ["verifying", "draining", "backing-up", "rehearsing", "switching", "restarting", "health"];
-export type UpdateStep = typeof UPDATE_STEPS[number];
-export type RuntimePhase = typeof RUNTIME_PHASES[number];
-export declare const STEP_WORDS: Record<UpdateStep, string>;
-export type When = "now" | "when-idle" | "at";
-export type RuntimeRef = {
-    version: string;
-    dist: string;
-};
-/** How many release-* runtimes stay on disk: the running one and the one before it. */
-export declare const KEEP_RUNTIMES = 2;
-/** The one-off launchd job the console starts the updater as. */
-export declare const UPDATE_JOB_LABEL = "com.toolroll.update";
-/** The update's journal (`toolroll-update.json`, `.last.json` and the stage's `update.json`):
- * src/contracts/update-journal.ts. */
-export type RuntimeUpdateJournal = RuntimeUpdateJournalRecord;
-export type PackageRelease = {
-    version: string;
-    tarball: string;
-    integrity: string;
-    attestations: string | null;
-};
-export type UpdateSystem = {
-    now: () => Date;
-    sleep: (ms: number) => Promise<void>;
-    release: (version: string) => Promise<PackageRelease>;
-    download: (url: string) => Promise<Uint8Array>;
-    attestations: (url: string) => Promise<unknown>;
-    /** Installs `release` from the registry into `runtimeDir`, has npm verify its
-     * registry signature and attestation there, checks the installed bytes are
-     * `release.integrity`, and returns the package's dist. */
-    install: (runtimeDir: string, release: PackageRelease) => Promise<string>;
-    /** Opens `copy` with the runtime at `dist`, which migrates it as that build would. */
-    rehearse: (dist: string, copy: string) => Promise<void>;
-    /** Every `toolroll` and `standing-orders` command on PATH: each must be a link into `from` to be switched. */
-    commands: (from: RuntimeRef) => string[];
-    /** The background service's definition, when one runs `from`. */
-    serviceUnit: (from: RuntimeRef) => string | null;
-    /** Every repo's watch daemon definition that runs `from`. */
-    watchUnits: (from: RuntimeRef) => string[];
-    /** npm's own Sigstore verifier: the bundle's certificate chains to Sigstore, its signature is in the transparency
-     * log, and the certificate names exactly this identity. */
-    sigstore: (bundle: unknown, identity: {
-        issuer: string;
-        identity: string;
-    }) => Promise<void>;
-    /** The processes the service runs now. */
-    servicePids: (unit: string) => Promise<number[]>;
-    /** Whether launchd has the service loaded now. */
-    serviceLoaded: (unit: string) => Promise<boolean>;
-    /** Unload the service; resolves once launchd no longer has it. */
-    stopService: (unit: string) => Promise<void>;
-    /** Load and start the service from its definition on disk. */
-    restartService: (unit: string) => Promise<void>;
-    processAlive: (pid: number) => boolean;
-    healthy: (j: RuntimeUpdateJournal) => Promise<boolean>;
-    healthTimeoutMs?: number;
-    /** How long stopped service processes may take to exit. */
-    exitTimeoutMs?: number;
-    /** Bytes free for this user in the folder `dir` is on. */
-    freeBytes?: (dir: string) => number;
-    /** Fault injection for state-machine tests, never selectable by a flag. `kept-aside`: the live database was just
-     * kept aside, before the backup is put back. */
-    checkpoint?: (phase: RuntimePhase | "kept-aside") => void;
-};
-export type UpdateOutcome = {
-    ok: boolean;
-    phase: RuntimeUpdateJournal["phase"];
-    message: string;
-    journal: RuntimeUpdateJournal | null;
-};
-export declare const runtimeUpdateTerminal: (phase: string) => boolean;
-/** How long a launched or resuming updater is expected to take to start and hold the lock. */
-export declare const UPDATER_START_MS: number;
-export declare function readRuntimeUpdate(stateDir: string, file?: string): RuntimeUpdateJournal | null;
-/** The update `--rollback` returns from: the last one that completed, whatever was attempted since. */
-export declare function lastCompletedUpdate(stateDir: string): RuntimeUpdateJournal | null;
-/** Running work by name, for a refusal a person can act on. */
-export declare function runningWorkWords(db: DatabaseSync): string | null;
-export type Provenance = {
-    repository: string;
-    workflow: string;
-    issuer: string;
-    identity: string;
-    bundle: unknown;
-};
-/** The npm provenance for exactly these bytes of Toolroll itself must be signed by a certificate that names the
- * Toolroll repository, its publish workflow and GitHub Actions as the issuer. The statement's own claims name
- * nobody: only the certificate, whose key must have signed the statement. Sigstore's chain and transparency log are
- * then checked by npm's own verifier (UpdateSystem.sigstore) for the identity returned here. */
-export declare function checkProvenance(attestations: unknown, version: string, sha512Hex: string): Provenance;
-/** Headlines of this version's changelog section: its bold lead phrases. */
-export declare function releaseNotes(changelog: string, version: string): string[];
-/** Every rename here: what is renamed is flushed first (a file itself, a link
- * by its directory), and the directory after, so a crash never leaves a torn
- * database, catalog or command. */
-export declare function durableRename(temp: string, target: string): void;
-type Moved = {
-    into: string;
-    where: string;
-    rows?: string;
-};
-export declare const CHAT_MOVES: Record<string, Moved>;
-/** The tables a migration may remove whole (v115's removed features). */
-export declare const RETIRED_TABLES: readonly string[];
-/** A saved routine, as its move into a scheduled flow must account for it. */
-type RoutineDigest = {
-    id: number;
-    repo: string;
-    name: string;
-    live: boolean;
-};
-export type TableDigest = {
-    name: string;
-    columns: string[];
-    rowid: boolean;
-    count: number;
-    last: number;
-    hash?: string;
-    summed?: number;
-    nonNull?: Record<string, number>;
-    carry?: number;
-    received?: {
-        count: number;
-        nonNull: Record<string, number>;
-    };
-    routines?: RoutineDigest[];
-    moved?: {
-        rows: number;
-        found: number;
-    };
-    compactedRuns?: {
-        run: number;
-        count: number;
-    }[];
-    summaries?: {
-        run: number;
-        hash: string;
-    }[];
-};
-/** Each saved table's columns, row count and last rowid; the append-only ones hashed (deploy-browser's rehearsal check).
- * Bounded: only the ledger and small tables are read row by row. */
-export declare function historySnapshot(db: DatabaseSync): TableDigest[];
-/** The tables whose saved history the migration changed beyond what HISTORY_RULES declares. */
-export declare function changedHistory(db: DatabaseSync, before: TableDigest[]): string[];
-export type StartOptions = {
-    stateDir: string;
-    databaseFile: string;
-    current: RuntimeRef;
-    actor: string;
-    version: string;
-    when: When;
-    at?: string | null;
-    /** An older version replaces the current one only when asked for by name. */
-    allowDowngrade?: boolean;
-};
-/** Record an update without running it: the console's job resumes exactly this journal id. */
-export declare function prepareRuntimeUpdate(o: StartOptions, now: Date): RuntimeUpdateJournal | {
-    refused: string;
-};
-/** Start an update: stage, verify, then run the journaled steps. */
-export declare function startRuntimeUpdate(o: StartOptions, system: UpdateSystem): Promise<UpdateOutcome>;
-/** Return to the runtime and database backup an update replaced. */
-export declare function startRuntimeRollback(o: {
-    stateDir: string;
-    databaseFile: string;
-    current: RuntimeRef;
-    actor: string;
-    when: When;
-}, system: UpdateSystem): Promise<UpdateOutcome>;
-/** Continue a saved update after a crash, where it left off. With `id` (the console's job), only that update:
- * a job never starts a fresh one, and a finished, replaced or rolled-back one is left alone. */
-export declare function resumeRuntimeUpdate(stateDir: string, system: UpdateSystem, id?: string): Promise<UpdateOutcome>;
-/** A prepared update whose job could not start. */
-export declare function abandonRuntimeUpdate(stateDir: string, id: string, why: string, now: Date): void;
-/** `locked`: a test's seam, called once the updater's lock is held and before the journal is read again. */
-export declare function requestRuntimeUpdateCancel(stateDir: string, now?: Date, seams?: {
-    locked?: () => void;
-}): string;
-/** Keep the newest release-* runtimes (and any in `keep`), at most KEEP_RUNTIMES; deploy-browser's browser-* and
- * the rollback-* records are not this updater's to remove. */
-export declare function pruneRuntimes(stateDir: string, keep: readonly string[]): string[];
-export type RuntimeUpdateStatus = {
-    journal: RuntimeUpdateJournal | null;
-    running: boolean;
-    /** A completed update whose What's new card has not been dismissed. */
-    whatsNew: {
-        version: string;
-        notes: string[];
-    } | null;
-    /** The last completed update `--rollback` returns from, whatever was attempted since. */
-    lastUpdate: {
-        from: string;
-        to: string;
-    } | null;
-};
-export declare function runtimeUpdateStatus(stateDir: string): RuntimeUpdateStatus;
-/** An update that is waiting, what on, and the one action that clears it: for `toolroll status` and the console.
- * `inTheWay` asks whether a finished run still holds it up; a stopped update whose run has since cleared says nothing. */
-export type { UpdateWaiting };
-export declare function updateWaitingOf(stateDir: string, inTheWay: (run: number) => boolean): UpdateWaiting | null;
-/** An updater that ended while letting work finish (a crash, a kill, the Mac restarting) leaves new work paused with
- * nobody left to lift the pause. With no updater holding the update, the pause is lifted here and the update says it
- * stopped. Nothing was switched before the backup, so nothing else needs putting back. The background worker's
- * reconcile, `toolroll status` and the console run this. Returns what it said, or null. */
-export declare function releaseStalledUpdate(stateDir: string, now: Date): string | null;
-/** What `toolroll status` and the console show: a stalled `toolroll update` released first, then this installation's
- * waiting update, `toolroll update`'s or the desktop app's. */
-export declare function waitingUpdate(databaseFile: string, inTheWay: (run: number) => boolean, now: Date, desktopStates?: readonly string[]): UpdateWaiting | null;
-export declare function markWhatsNewSeen(stateDir: string): void;
-type Exec = (command: string, args: string[], options?: {
-    cwd?: string;
-    timeout?: number;
-    input?: string;
-}) => {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-};
-export declare function currentRuntime(version: string): RuntimeRef;
-/** Seams for tests: npm, node and ps (`exec`), launchctl or systemctl (`run`), process liveness, and launchd's waits
- * (`sleep`); for the laptop service on Linux, the platform, process identity (`probe`), the host name its process
- * record names, and the console proof (`consoleProof`: the database's console is live at that version). */
-export type MachineSeams = {
-    exec?: Exec;
-    run?: SupervisorRunner;
-    alive?: (pid: number) => boolean;
-    sleep?: (ms: number) => Promise<void>;
-    execPath?: string;
-    platform?: NodeJS.Platform;
-    probe?: ProcessProbe;
-    host?: string;
-    consoleProof?: (databaseFile: string, version: string) => Promise<boolean>;
-};
-export declare function machineSystem(home?: string, env?: Record<string, string | undefined>, seams?: MachineSeams): UpdateSystem;
-/** npm's own Sigstore verifier. Found from npm itself (the `npm` on PATH, then the one beside node), never only from
- * `npm root --global`: with a custom global prefix (npm's advice for permission errors) that folder holds the global
- * packages, not npm. */
-export declare function findSigstoreVerifier(o: {
-    path: string;
-    execPath: string;
-    npmRoot: () => string | null;
-}): string | null;
-export declare function launchRuntimeUpdate(args: {
-    databaseFile: string;
-    id: string;
-    dist?: string;
-}, seams?: {
-    home?: string;
-    run?: SupervisorRunner;
-    platform?: NodeJS.Platform;
-    npmBin?: () => Promise<string | null>;
-    now?: () => Date;
-}): Promise<void>;
-/** The job's last act: its definition goes, so nothing can start it again. Only the definition for this id. */
-export declare function retireUpdateJob(id: string, home?: string): void;

package/dist/tools-ui.d.ts

@@ -1,51 +0,0 @@
-/** Settings → Tools: one project's MCP servers, in plain words. Secrets are
- * entered here and nowhere else, and never shown again. Built from the revamp kit (src/design/KIT.md): each tool and
- * each service is a record with one action; the password is asked only once a tool or service is picked. */
-import { type Html } from "./html.js";
-import { type FoundTool, type ProjectTool, type ToolSpec } from "./project-tools.js";
-/** Kept for the console's style bundle (server/chrome.ts): the page is built from the kit and needs none of its own. */
-export declare const TOOLS_CSS = "";
-export type ToolsView = {
-    repo: string;
-    project: string;
-    /** Services connected by signing in, and the kit a Connect came from, if any. */
-    connections: {
-        id: string;
-        label: string;
-        about: string;
-        state: "connected" | "open" | "taken";
-        local?: true;
-        research?: string;
-    }[];
-    kit: string | null;
-    /** The service a link asked for (a kit's checklist, the lead): listed first, its Connect the page's one primary. */
-    wanted: string | null;
-    tools: {
-        tool: ProjectTool;
-        secretsSet: string[];
-    }[];
-    catalog: (ToolSpec & {
-        label: string;
-    })[];
-    found: FoundTool[];
-    /** Where this computer keeps tool secrets (project-tools.ts toolSecretStorage): said plainly when it's files only. */
-    storage?: {
-        words: string;
-        filesOnly: boolean;
-        problem?: string;
-    };
-    /** The person's other projects and the one-click services still open there: where a connection here can also go. */
-    others?: {
-        repo: string;
-        project: string;
-        open: string[];
-    }[];
-};
-/** The project chooser: it opens the chosen project at once; without scripts, its button does. */
-export declare function toolsProjectPicker(projects: readonly string[], chosen: string, keep?: Record<string, string>): Html | "";
-/** Choosing another project marks every form on the page as stale before it reloads, so a tap racing the reload is refused. */
-export declare const TOOLS_PROJECT_SCRIPT = "(function(){var s=document.querySelector('select[data-tools-project]');if(!s)return;s.addEventListener('change',function(){document.querySelectorAll('input[name=shown]').forEach(function(i){i.value=s.value;});});})();";
-export declare function toolsHtml(view: ToolsView, csrf: string, canManage: boolean, message?: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;

package/dist/transitions-recipes.d.ts

@@ -1 +0,0 @@
-export declare const TRANSITIONS_CSS = "\n/* Transitions.dev \u2014 05-menu-dropdown.md */\n:root {\n  --dropdown-open-dur: 250ms;\n  --dropdown-close-dur: 150ms;\n  --dropdown-pre-scale: 0.97;\n  --dropdown-closing-scale: 0.99;\n  --dropdown-ease: cubic-bezier(0.22, 1, 0.36, 1);\n}\n\n.t-dropdown {\n  transform-origin: top left;\n  transform: scale(var(--dropdown-pre-scale));\n  opacity: 0;\n  pointer-events: none;\n  transition:\n    transform var(--dropdown-open-dur) var(--dropdown-ease),\n    opacity   var(--dropdown-open-dur) var(--dropdown-ease);\n  will-change: transform, opacity;\n}\n.t-dropdown[data-origin=\"top-right\"]     { transform-origin: top right; }\n.t-dropdown[data-origin=\"top-center\"]    { transform-origin: top center; }\n.t-dropdown[data-origin=\"bottom-left\"]   { transform-origin: bottom left; }\n.t-dropdown[data-origin=\"bottom-center\"] { transform-origin: bottom center; }\n.t-dropdown[data-origin=\"bottom-right\"]  { transform-origin: bottom right; }\n\n.t-dropdown.is-open {\n  transform: scale(1);\n  opacity: 1;\n  pointer-events: auto;\n}\n.t-dropdown.is-closing {\n  transform: scale(var(--dropdown-closing-scale));\n  opacity: 0;\n  pointer-events: none;\n  transition:\n    transform var(--dropdown-close-dur) var(--dropdown-ease),\n    opacity   var(--dropdown-close-dur) var(--dropdown-ease);\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .t-dropdown { transition: none !important; }\n}\n\n/* Transitions.dev \u2014 07-panel-reveal.md */\n:root {\n  --panel-open-dur: 400ms;\n  --panel-close-dur: 350ms;\n  --panel-translate-y: 100px;\n  --panel-blur: 2px;\n  --panel-ease: cubic-bezier(0.22, 1, 0.36, 1);\n}\n\n.t-panel-slide {\n  transform: translateY(var(--panel-translate-y));\n  opacity: 0;\n  filter: blur(var(--panel-blur));\n  pointer-events: none;\n  transition:\n    transform var(--panel-close-dur) var(--panel-ease),\n    opacity   var(--panel-close-dur) var(--panel-ease),\n    filter    var(--panel-close-dur) var(--panel-ease);\n  will-change: transform, opacity, filter;\n}\n.t-panel-slide[data-open=\"true\"] {\n  transform: translateY(0);\n  opacity: 1;\n  filter: blur(0);\n  pointer-events: auto;\n  transition:\n    transform var(--panel-open-dur) var(--panel-ease),\n    opacity   var(--panel-open-dur) var(--panel-ease),\n    filter    var(--panel-open-dur) var(--panel-ease);\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .t-panel-slide { transition: none !important; }\n}\n\n/* Transitions.dev \u2014 16-tabs-sliding.md */\n:root {\n  --tabs-dur: 250ms;\n  --tabs-ease: cubic-bezier(0.22, 1, 0.36, 1);\n  --tabs-text-muted: rgba(15, 15, 15, 0.8);\n  --tabs-text-active: #0f0f0f;\n  --tabs-bar-bg: #f1f1f1;\n  --tabs-pill-bg: #ffffff;\n}\n\n/* The bar is just a flex container with padding for the pill\n   to sit inside. Tabs sit on z-index: 1, the pill on z-index: 0,\n   so labels read above the pill background. */\n.t-tabs {\n  position: relative;\n  display: inline-flex;\n  align-items: center;\n  gap: 3px;\n  padding: 3px;\n  border-radius: 48px;\n  background: var(--tabs-bar-bg);\n}\n.t-tab {\n  position: relative;\n  appearance: none;\n  border: 0;\n  background: transparent;\n  height: 30px;\n  padding: 4px 12px;\n  color: var(--tabs-text-muted);\n  cursor: pointer;\n  border-radius: 48px;\n  z-index: 1;\n  transition: color var(--tabs-dur) var(--tabs-ease);\n}\n.t-tab:not([aria-selected=\"true\"]):hover,\n.t-tab[aria-selected=\"true\"] {\n  color: var(--tabs-text-active);\n}\n\n/* The pill: width + transform are written inline by JS so\n   the transition tweens between the previous and next\n   measured positions. */\n.t-tabs-pill {\n  position: absolute;\n  top: 3px;\n  left: 0;\n  height: 30px;\n  width: 0;\n  background: var(--tabs-pill-bg);\n  border-radius: 48px;\n  transform: translateX(0);\n  transition:\n    transform var(--tabs-dur) var(--tabs-ease),\n    width     var(--tabs-dur) var(--tabs-ease);\n  will-change: transform, width;\n  z-index: 0;\n  pointer-events: none;\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .t-tabs-pill, .t-tab { transition: none !important; }\n}\n\n/* Transitions.dev \u2014 21-accordion.md */\n:root {\n  --acc-expand: 250ms;\n  --acc-collapse: 250ms;\n  --acc-chevron: 250ms;\n  --acc-ease: cubic-bezier(0.22, 1, 0.36, 1);\n}\n\n/* grid-template-rows 0fr \u2192 1fr gives a clean height animation\n   with no JS measurement; the inner element clips overflow. */\n.t-acc-panel {\n  display: grid;\n  grid-template-rows: 0fr;\n  transition: grid-template-rows var(--acc-collapse) var(--acc-ease);\n}\n.t-acc[data-open=\"true\"] .t-acc-panel {\n  grid-template-rows: 1fr;\n  transition: grid-template-rows var(--acc-expand) var(--acc-ease);\n}\n.t-acc-panel-inner {\n  overflow: hidden;\n  opacity: 0;\n  filter: blur(2px);\n  transition:\n    opacity var(--acc-collapse) var(--acc-ease),\n    filter var(--acc-collapse) var(--acc-ease);\n}\n.t-acc[data-open=\"true\"] .t-acc-panel-inner {\n  opacity: 1;\n  filter: blur(0);\n  transition:\n    opacity var(--acc-expand) var(--acc-ease),\n    filter var(--acc-expand) var(--acc-ease);\n}\n/* The one disclosure glyph (disclosure.ts): a right chevron that\n   turns down when the fold opens; non-scaling-stroke keeps the\n   stroke width constant through the turn. */\n.t-acc-chevron {\n  display: inline-flex;\n  transform: rotate(0deg);\n  transform-origin: center;\n  transition: transform var(--acc-chevron) var(--acc-ease);\n}\n.t-acc-chevron path { vector-effect: non-scaling-stroke; }\n.t-acc[data-open=\"true\"] .t-acc-chevron {\n  transform: rotate(90deg);\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .t-acc-panel, .t-acc-panel-inner, .t-acc-chevron {\n    transition: none !important;\n  }\n}\n";

package/dist/tree-proof.d.ts

@@ -1,34 +0,0 @@
-/**
- * The read-only roles' clean-tree proof (planner, scout — mate arc §10,
- * v4 review finding 4). `git status --porcelain` alone is not a proof: it
- * omits IGNORED paths, so an agent could leave a generated file behind
- * and pass; and a pathname filter that exempts the protocol files
- * regardless of index status would let an agent `git add` its own
- * handoff and pass with a dirty index. So: ignored paths are snapshotted
- * BEFORE the agent runs and any new one afterwards is foreign; and a
- * protocol file is admitted only as plain untracked (`??`) — staged is
- * foreign. Ignored directories are collapsed by git (`!! build/`), so a
- * write INTO a directory that was already ignored before the agent ran
- * (a dependency tree the setup command produced) is not detected — that
- * residual is stated here rather than wished away.
- */
-import type { Runner } from "./builder.js";
-/** The ignored paths git reports right now — the "before" of a proof. */
-export declare function snapshotIgnored(git: Runner, cwd: string): Promise<Set<string> | null>;
-export type TreeProof = {
-    ok: true;
-} | {
-    ok: false;
-    reason: "git" | "dirty-tree";
-    foreign: string[];
-};
-/**
- * Everything in the tree that is not (a) an ignored path that was already
- * ignored before, (b) one of this attempt's own protocol files as PLAIN
- * untracked, or (c) the pool's untracked lease marker.
- */
-export declare function proveTreeUntouched(git: Runner, cwd: string, args: {
-    ignoredBefore: ReadonlySet<string>;
-    protocolFiles: readonly string[];
-    marker: string;
-}): Promise<TreeProof>;