basepad 0.0.0-stage → 0.0.0

package/dist/mission-control/launch.js

@@ -0,0 +1,362 @@
+import { Box, render, Text } from "ink";
+import { createElement as h } from "react";
+import { palette } from "./frame.js";
+const withArt = ({ cols, rows, color }) => color === "rgb" && cols >= ART_COLS && (rows ?? Number.POSITIVE_INFINITY) >= MIN_ART_ROWS + 2;
+/** The rows the art takes in `rows` with its padding: the whole sky where it fits, less above. */
+const artRows = (rows) => Math.min(ART_ROWS, rows - 2);
+export function launchFrame(input) {
+    const c = palette(input.color);
+    const seconds = input.elapsed === undefined ? undefined : Math.floor(input.elapsed);
+    const clock = seconds === undefined
+        ? undefined
+        : `T+${[seconds / 3600, (seconds / 60) % 60, seconds % 60]
+            .map((n) => String(Math.floor(n)).padStart(2, "0"))
+            .join(":")}`;
+    return beside(withArt(input)
+        ? pixels(scene(input).slice(-2 * artRows(input.rows ?? Number.POSITIVE_INFINITY)), c)
+        : [], checklist({
+        ...input,
+        lamp: "GO",
+        status: launchStatus(input, c),
+        ...(clock === undefined ? {} : { clock }),
+    }, c));
+}
+/** The art, if any, with the checklist to its right. */
+function beside(art, list) {
+    return h(Box, { flexDirection: "row", gap: 4, paddingX: 1, paddingY: 1 }, ...(art.length > 0 ? [h(Box, { key: "art", flexDirection: "column" }, ...art)] : []), list);
+}
+function launchStatus({ checks, lift }, c) {
+    const failed = checks.find((check) => check.state === "nogo");
+    if (failed !== undefined)
+        return [`NO-GO  ·  ${failed.name}`, c.bad];
+    if (checks.every((check) => check.state === "go"))
+        return lift > 0 ? ["LIFT-OFF", c.ok] : ["ALL SYSTEMS GO", c.ok];
+    return ["PRE-LAUNCH CHECKS", c.warn];
+}
+// ── the checklist ─────────────────────────────────────────────────────────────────────────────
+/** The art needs this many columns beside the checklist, this many rows, and a colour per pixel. */
+const ART_COLS = 70;
+const ART_ROWS = 18;
+/** The least it shows: the rocket, its tower and pad, with the sky above cut. */
+const MIN_ART_ROWS = 13;
+const WIDTH = 34;
+function checklist(list, c) {
+    const rule = h(Text, { color: c.dim }, "─".repeat(WIDTH));
+    // Dark type on a lit lamp; without colour, the terminal's own.
+    const onLamp = c.keyBg === undefined ? undefined : "#1a1b26";
+    const lit = (text, bg) => h(Text, { color: onLamp, backgroundColor: bg, bold: true }, ` ${text} `);
+    const rows = list.checks.map((check) => {
+        const on = check.state !== "waiting";
+        const lamp = check.state === "go"
+            ? lit(list.lamp, c.ok)
+            : check.state === "nogo"
+                ? lit("NO-GO", c.bad)
+                : check.state === "active"
+                    ? h(Text, { color: c.warn, bold: true }, " ·· ")
+                    : h(Text, null, "");
+        return h(Text, { key: check.name }, h(Text, { color: on ? c.text : c.dim }, check.name.padEnd(WIDTH - 8, on ? "." : " ")), lamp);
+    });
+    const [said, tone] = list.status;
+    return h(Box, { key: "checklist", flexDirection: "column", justifyContent: "center" }, h(Text, null, h(Text, { color: c.text, bold: true }, "BASEPAD"), h(Text, { color: c.dim }, "  │  "), h(Text, { color: c.mute }, list.title)), h(Text, { color: c.dim }, list.subtitle.toUpperCase()), rule, ...rows, rule, h(Text, null, ...(list.clock === undefined
+        ? []
+        : [h(Text, { key: "clock", color: c.text, bold: true }, list.clock.padEnd(14))]), h(Text, { color: tone, bold: true }, said)), ...(list.note === undefined ? [] : [h(Text, { key: "note", color: c.mute }, list.note)]));
+}
+// ── the rocket ────────────────────────────────────────────────────────────────────────────────
+/** A Saturn-style rocket, a character per pixel: each letter a colour (`colours`), `.` none. */
+const ROCKET = [
+    "....S....",
+    "....S....",
+    "...SwS...",
+    "...WWw...",
+    "..WWWWw..",
+    "..DDDDD..",
+    "..WWWWw..",
+    "..WKWWw..",
+    "..DDDDD..",
+    "..WWWWw..",
+    "..WWWKw..",
+    "..WWWWw..",
+    "..DDDDD..",
+    "..BBBBB..",
+    "..WWWWw..",
+    "..WKKWw..",
+    "..WKKWw..",
+    "..WWWWw..",
+    "..WWWKK..",
+    ".DWWWKKD.",
+    "DDWWWWwDD",
+    "D.SSSSS.D",
+];
+const FLAME = [
+    ["...LLL...", "...YLY...", "....Y...."],
+    ["...LLL...", "...LYL...", "...YOY...", "....O...."],
+];
+const PLUME = [
+    ["..LLLLL..", "..YLLLY..", "...YYY...", "...OYO...", "....O....", "....O...."],
+    ["..LLLLL..", "..LLLLL..", "...YLY...", "...YOY...", "...O.O...", "....O...."],
+];
+const WIDE = 26;
+const TALL = 36;
+const ROCKET_X = 12;
+const PAD = TALL - 3;
+const ROCKET_TOP = PAD - ROCKET.length - 1;
+const STARS = [
+    [1, 2],
+    [22, 5],
+    [8, 1],
+    [24, 14],
+    [17, 0],
+];
+/** A blank sky, `put` to draw a pixel into it, and `stamp` to draw rows of them. */
+function canvas() {
+    const px = Array.from({ length: TALL }, () => Array(WIDE).fill("."));
+    const put = (x, y, ch) => {
+        const row = px[y];
+        if (ch !== "." && row !== undefined && x >= 0 && x < WIDE)
+            row[x] = ch;
+    };
+    const stamp = (rows, x, y) => {
+        for (const [dy, row] of rows.entries())
+            for (const [dx, ch] of [...row].entries())
+                put(x + dx, y + dy, ch);
+    };
+    return { rows: () => px.map((row) => row.join("")), put, stamp };
+}
+const TOWER_TOP = ROCKET_TOP - 2;
+/** Where the tower's beacon blinks. */
+const BEACON = [5, TOWER_TOP - 2];
+/** The stars, the tower (its beacon dark, its arms away from the rocket) and the pad. */
+function ground(put, armsIn) {
+    for (const [x, y] of STARS)
+        put(x, y, "*");
+    // The umbilical tower: two legs and a lattice.
+    for (let y = TOWER_TOP; y < PAD; y++) {
+        put(3, y, "T");
+        put(7, y, "T");
+        put(4 + ((y - TOWER_TOP) % 3), y, "t");
+    }
+    put(5, TOWER_TOP - 1, "T");
+    put(...BEACON, "t");
+    // Its arms hold the rocket until it is cleared to go.
+    for (const y of [ROCKET_TOP + 4, ROCKET_TOP + 10, ROCKET_TOP + 16])
+        for (let x = 8; x < (armsIn ? ROCKET_X + 2 : 10); x++)
+            put(x, y, "T");
+    for (let x = 0; x < WIDE; x++)
+        put(x, PAD, "D");
+    for (let x = 1; x < WIDE - 1; x++)
+        put(x, PAD + 1, x > 10 && x < 22 ? "K" : "D");
+}
+/** The pad as pixels, a row of letters each: the tower, the rocket risen `lift`, its flame. */
+function scene({ checks, tick, lift }) {
+    const { rows, put, stamp } = canvas();
+    const go = checks.every((check) => check.state === "go");
+    ground(put, !go);
+    if (tick % 10 < 5)
+        put(...BEACON, "R");
+    const top = ROCKET_TOP - lift;
+    stamp(ROCKET, ROCKET_X, top);
+    if (go)
+        stamp((lift > 0 ? PLUME : FLAME)[tick % 2], ROCKET_X, top + ROCKET.length);
+    if (lift > 0)
+        for (let x = 0; x < WIDE; x++)
+            if ((x + tick) % 3 !== 0)
+                put(x, PAD - 1, "S");
+    return rows();
+}
+/**
+ * The art in layers, for drawing it elsewhere (the README's rocket, `scripts/rocket-svg.ts`): the
+ * ground with the tower's arms away, the rocket and its flames as stamped at `x`, `top`, and each
+ * letter's colour.
+ */
+export function rocketArt() {
+    const { rows, put } = canvas();
+    ground(put, false);
+    return {
+        wide: WIDE,
+        tall: TALL,
+        ground: rows(),
+        beacon: BEACON,
+        rocket: ROCKET,
+        flames: FLAME,
+        plumes: PLUME,
+        x: ROCKET_X,
+        top: ROCKET_TOP,
+        colours: colours(palette("rgb")),
+    };
+}
+function colours(c) {
+    return {
+        W: c.text,
+        w: c.soft,
+        S: c.mute,
+        B: c.accent,
+        Y: c.warn,
+        R: c.bad,
+        "*": c.dim,
+        T: c.dim,
+        D: "#414868",
+        K: "#24283b",
+        t: "#3b4261",
+        L: "#fff1c1",
+        O: "#ff9e64",
+    };
+}
+/** Two pixel rows to a line of text: `▀` in the top one's colour, on the bottom one's. */
+function pixels(rows, c) {
+    const colour = colours(c);
+    const out = [];
+    for (let y = 0; y < rows.length; y += 2) {
+        const top = [...rows[y]];
+        const bottom = [...(rows[y + 1] ?? "")];
+        out.push(h(Text, { key: y }, ...top.map((t, x) => {
+            const b = bottom[x] ?? ".";
+            if (t === "." && b === ".")
+                return h(Text, { key: x }, " ");
+            if (t === ".")
+                return h(Text, { key: x, color: colour[b] }, "▄");
+            if (b === ".")
+                return h(Text, { key: x, color: colour[t] }, "▀");
+            return h(Text, { key: x, color: colour[t], backgroundColor: colour[b] }, "▀");
+        })));
+    }
+    return out;
+}
+export function landingFrame(input) {
+    const c = palette(input.color);
+    const art = input.color === "rgb" && input.cols >= ART_COLS;
+    const lamp = input.state === "stopped" ? "go" : input.state === "failed" ? "nogo" : "active";
+    const status = input.state === "stopped"
+        ? ["SPLASHDOWN  ·  all stopped", c.ok]
+        : input.state === "failed"
+            ? ["NO-GO  ·  not everything stopped", c.bad]
+            : ["DESCENT", c.warn];
+    const kept = input.kept ?? [];
+    const names = kept.map((key) => `\`${key}\``).join(", ");
+    const note = input.state !== "stopped"
+        ? undefined
+        : kept.length === 0
+            ? "`basepad up` relaunches."
+            : `${names} ${kept.length > 1 ? "run" : "runs"} on main's and keep${kept.length > 1 ? "" : "s"} running. \`basepad up\` relaunches.`;
+    return beside(art ? pixels(capsule(input), c) : [], checklist({
+        ...input,
+        subtitle: `${input.project}  ·  ${input.environment}`,
+        title: "SPLASHDOWN",
+        lamp: "SAFE",
+        checks: input.parts.map((name) => ({ name, state: lamp })),
+        status,
+        ...(note === undefined ? {} : { note }),
+    }, c));
+}
+/** The capsule's parachute, its gores red and white. */
+const CHUTE = [
+    "......RRWWRR......",
+    "...RRWWRRWWRRWW...",
+    "..WWRRWWRRWWRRWW..",
+    ".RRWWRRWWRRWWRRWW.",
+    "RRWWRRWWRRWWRRWWRR",
+    "t.......t........t",
+];
+const CAPSULE = ["...W...", "..WWw..", ".WWWWw.", "WWWWWww", "DDDDDDD"];
+/** The sky and sea as pixels: the capsule under its chute `drop` down, swaying, then splashed. */
+function capsule({ tick, drop, state }) {
+    const px = Array.from({ length: TALL }, () => Array(WIDE).fill("."));
+    const put = (x, y, ch) => {
+        const row = px[y];
+        if (ch !== "." && row !== undefined && x >= 0 && x < WIDE)
+            row[x] = ch;
+    };
+    const stamp = (rows, x, y) => {
+        for (const [dy, row] of rows.entries())
+            for (const [dx, ch] of [...row].entries())
+                put(x + dx, y + dy, ch);
+    };
+    for (const [x, y] of STARS)
+        put(x, y, "*");
+    const sea = TALL - 4;
+    const down = state === "stopped";
+    // The lowest it comes before landing, and where it floats after.
+    const lowest = sea - CAPSULE.length - CHUTE.length - 7;
+    const y = down ? sea - CAPSULE.length - CHUTE.length - 5 : Math.min(lowest, drop);
+    const sway = down ? 0 : tick % 20 < 10 ? 0 : 1;
+    const x = 4 + sway;
+    if (!down) {
+        stamp(CHUTE, x, y);
+        // Shroud lines from the chute's edge and middle to the capsule's top.
+        for (let i = 1; i <= 5; i++) {
+            const row = y + CHUTE.length - 1 + i;
+            put(x + 1 + Math.round((i * 7) / 5), row, "t");
+            put(x + 16 - Math.round((i * 6) / 5), row, "t");
+            put(x + 9, row, "t");
+        }
+    }
+    const capsuleY = down ? sea - CAPSULE.length + 1 : y + CHUTE.length + 5;
+    stamp(CAPSULE, x + 6, capsuleY);
+    // The sea, its waves rolling with the beat; a splash once it is down.
+    for (let row = sea; row < TALL; row++)
+        for (let col = 0; col < WIDE; col++)
+            put(col, row, (col + tick + row) % 4 === 0 ? "w" : "B");
+    if (down)
+        for (const dx of [-1, 7, -2, 8])
+            put(x + 6 + dx, sea - 1 - (Math.abs(dx) % 2), "w");
+    return px.map((row) => row.join(""));
+}
+// ── the live view ─────────────────────────────────────────────────────────────────────────────
+/** A beat of the animation. */
+const BEAT_MS = 100;
+/** How long the splashdown shows before `down` returns. */
+const SPLASH_MS = 300;
+/** Draws the landing on the terminal, in place, until it lands or fails. */
+export function landing(options) {
+    let tick = 0;
+    let state = "stopping";
+    const draw = () => landingFrame({
+        ...options,
+        state,
+        tick,
+        drop: Math.floor(tick / 2),
+        cols: process.stdout.columns || Number(process.env.COLUMNS) || 80,
+    });
+    const app = render(draw(), { exitOnCtrlC: true, patchConsole: false });
+    const timer = setInterval(() => {
+        tick++;
+        app.rerender(draw());
+    }, BEAT_MS);
+    const close = (then) => {
+        clearInterval(timer);
+        state = then;
+        app.rerender(draw());
+    };
+    return {
+        async land() {
+            close("stopped");
+            await new Promise((resolve) => setTimeout(resolve, SPLASH_MS));
+            app.unmount();
+        },
+        fail() {
+            close("failed");
+            app.unmount();
+        },
+    };
+}
+/** How long setup's lift-off plays. */
+const SETUP_LIFT_OFF_MS = 1500;
+/**
+ * Plays the lift-off on the terminal, in place, then leaves the empty pad: setup's last moment,
+ * once every step is done.
+ */
+export async function liftOff(input) {
+    let tick = 0;
+    const draw = () => launchFrame({ ...input, tick, lift: Math.floor(tick ** 2 / 4) });
+    const app = render(draw(), { exitOnCtrlC: true, patchConsole: false });
+    await new Promise((done) => {
+        const timer = setInterval(() => {
+            tick++;
+            app.rerender(draw());
+            if (tick * BEAT_MS >= SETUP_LIFT_OFF_MS) {
+                clearInterval(timer);
+                done();
+            }
+        }, BEAT_MS);
+    });
+    app.unmount();
+}

package/dist/mission-control/model.js

@@ -0,0 +1,325 @@
+/**
+ * Mission control's model: what it shows (a snapshot of the project's environments and their logs,
+ * read from the supervisor) and what the developer chose to look at (the view), with the pure
+ * function that turns a key press into the next view.
+ */
+import { ofDaemon } from "../layout.js";
+/** The view mission control opens on: the environment `basepad up` ran in. */
+export function initialView(selected) {
+    return { selected, quit: false };
+}
+/** The selected environment: the one the view names, else the first. */
+export function selectedOf(snapshot, view) {
+    return (snapshot.environments.find((env) => env.namespace === view.selected) ?? snapshot.environments[0]);
+}
+/** An environment's apps, then its services: the order the view lists and steps through them. */
+export function partsOf(env) {
+    return env === undefined ? [] : [...env.apps, ...env.services];
+}
+const DOING = {
+    start: "Starting",
+    stop: "Stopping",
+    restart: "Restarting",
+};
+/** What space does: stops what runs or is on its way, else starts it. */
+function toggleOf(env, part) {
+    const states = part === undefined ? env.apps.map((app) => app.state) : [part.state];
+    return states.some((state) => state === "running" || state === "starting") ? "stop" : "start";
+}
+/** The parts whose lines the stream shows: the focused part, or all the environment's. */
+export function streamIds(snapshot, view) {
+    const env = selectedOf(snapshot, view);
+    const parts = partsOf(env);
+    const focused = parts.find((part) => part.id === view.focus);
+    return focused === undefined ? parts.map((part) => part.id) : [focused.id];
+}
+/** Every line the stream can show, scrolled all the way back, in arrival order. */
+export function streamLines(snapshot, view) {
+    return streamIds(snapshot, view)
+        .flatMap((id) => (snapshot.logs.get(id) ?? []).filter(printed))
+        .sort((a, b) => a.seq - b.seq);
+}
+/** A web page `enter` can open: an app's URL, or a service's page such as an inbox. */
+const isPage = (address) => /^https?:\/\//.test(address);
+/** Whether a line says anything: the blank ones an app prints are left out of the stream. */
+export const printed = (line) => line.text.trim() !== "";
+/** The index of the last line that arrived no later than `seq`; -1 when none did. */
+function indexOf(lines, seq) {
+    let i = lines.length - 1;
+    while (i >= 0 && lines[i].seq > seq)
+        i--;
+    return i;
+}
+/**
+ * The text a press types into a field: a character, or a paste without its control characters (a
+ * newline it was copied with, a tab), since a field is one line and a paste never acts; a named
+ * key types none.
+ */
+const textOf = (key) => typeof key !== "string"
+    ? [...key.paste].filter((c) => c >= " " && c !== "\u007f").join("")
+    : [...key].length === 1
+        ? key
+        : undefined;
+/**
+ * What a key press does. `page` is how many log lines the stream shows: a page up or down moves
+ * by that many. A paste is text in a text field (the search, a worktree's suffix) and no key
+ * anywhere else, so it never starts or stops anything.
+ */
+export function reduce(previous, key, snapshot, page = 10) {
+    const { notice: _, ...view } = previous;
+    if (view.confirm !== undefined)
+        return confirming(view, view.confirm, key, snapshot);
+    if (view.search?.typing)
+        return { view: typing(view, view.search.query, key, snapshot) };
+    if (typeof key !== "string")
+        return { view: previous };
+    const envs = snapshot.environments;
+    const env = selectedOf(snapshot, view);
+    const at = env === undefined ? 0 : envs.indexOf(env);
+    // Environments go round, by tab or arrow; a number picks one outright.
+    const select = (i) => {
+        const next = envs[i];
+        if (next === undefined)
+            return view;
+        return { selected: next.namespace, quit: false, ...(view.help ? { help: true } : {}) };
+    };
+    const turn = (by) => select((at + by + envs.length) % Math.max(1, envs.length));
+    // Focus steps from "all" (none) down through each part in order, and stops at the last.
+    const step = (by) => {
+        const ids = [undefined, ...partsOf(env).map((part) => part.id)];
+        const now = Math.max(0, ids.indexOf(view.focus));
+        const focus = ids[Math.max(0, Math.min(ids.length - 1, now + by))];
+        const { focus: _, until: __, ...rest } = view;
+        return focus === undefined ? rest : { ...rest, focus };
+    };
+    // Scrolling pauses the stream at a line, by its arrival, so new lines do not move it.
+    const scroll = (by) => {
+        const lines = streamLines(snapshot, view);
+        const { until: _, ...live } = view;
+        const last = lines.length - 1;
+        if (by === "live" || lines.length <= page)
+            return live;
+        const now = view.until === undefined ? last : Math.max(page - 1, indexOf(lines, view.until));
+        const at = by === "oldest" ? page - 1 : Math.max(page - 1, now + by);
+        return at >= last ? live : { ...view, until: lines[at].seq };
+    };
+    const focused = partsOf(env).find((part) => part.id === view.focus);
+    // One key never stops a whole environment: `space` takes a selected part, else asks for one.
+    if (key === "space" && focused === undefined) {
+        const notice = "Select an app or service first (↓); `basepad down` stops them all.";
+        return { view: { ...view, notice } };
+    }
+    const kind = key === "r"
+        ? "restart"
+        : key === "space" && env !== undefined
+            ? toggleOf(env, focused)
+            : undefined;
+    if (kind !== undefined) {
+        const intent = env === undefined ? undefined : actionOn(env, focused, kind);
+        if (intent === undefined)
+            return { view: { ...view, notice: `Nothing here to ${kind}.` } };
+        return { view: { ...view, notice: `${DOING[kind]} ${intent.label}…` }, intent };
+    }
+    if (/^[1-9]$/.test(key))
+        return { view: select(Number(key) - 1) };
+    // Open and copy take the selected part, else the environment's first app with an address.
+    const target = focused ?? env?.apps.find((app) => app.address !== undefined);
+    const noAddress = `${target?.name} has no domain, so no address to open or copy.`;
+    switch (key) {
+        case "return":
+            if (target === undefined)
+                return { view: { ...view, notice: "Nothing here to open." } };
+            if (target.address === undefined)
+                return { view: { ...view, notice: noAddress } };
+            if (!isPage(target.address)) {
+                const notice = `${target.name} is a service, with no page to open; c copies its address.`;
+                return { view: { ...view, notice } };
+            }
+            return { view, intent: { kind: "open", url: target.address } };
+        case "c":
+            if (target === undefined)
+                return { view: { ...view, notice: "Nothing here to copy." } };
+            if (target.address === undefined)
+                return { view: { ...view, notice: noAddress } };
+            return { view, intent: { kind: "copy", text: target.address } };
+        case "q":
+        case "ctrl-c":
+            return { view: { ...view, quit: true } };
+        case "up":
+        case "k":
+            return { view: step(-1) };
+        case "down":
+        case "j":
+            return { view: step(1) };
+        case "tab":
+        case "right":
+        case "l":
+            return { view: turn(1) };
+        case "shift-tab":
+        case "left":
+        case "h":
+            return { view: turn(-1) };
+        case "?": {
+            const { help, ...rest } = view;
+            return { view: help ? rest : { ...rest, help: true } };
+        }
+        case "pageup":
+            return { view: scroll(-page) };
+        case "pagedown":
+            return { view: scroll(page) };
+        case "home":
+        case "g":
+            return { view: scroll("oldest") };
+        case "end":
+        case "G":
+            return { view: scroll("live") };
+        case "a":
+            if (snapshot.work?.some((w) => w.kind === "add")) {
+                const notice = "A worktree is being added; a adds another once it is made.";
+                return { view: { ...view, notice } };
+            }
+            return { view, intent: { kind: "add" } };
+        case "d": {
+            if (env === undefined || env === envs[0]) {
+                return {
+                    view: { ...view, notice: "Main is not a worktree: only a worktree is removed here." },
+                };
+            }
+            if (snapshot.work?.some((w) => w.namespace === env.namespace)) {
+                return { view: { ...view, notice: `${env.label} is being removed.` } };
+            }
+            const confirm = { namespace: env.namespace, suffix: env.label, step: "remove" };
+            return { view: { ...view, confirm } };
+        }
+        case "/":
+            return { view: { ...view, search: { query: "", typing: true } } };
+        case "n":
+        case "N":
+            return {
+                view: view.search === undefined ? view : find(view, key === "n" ? -1 : 1, snapshot),
+            };
+        case "escape": {
+            // One layer at a time: the keys, then the search or the pause, then the focus.
+            if (view.help) {
+                const { help: _, ...rest } = view;
+                return { view: rest };
+            }
+            const { until, search, ...rest } = view;
+            if (until !== undefined || search !== undefined)
+                return { view: rest };
+            const { focus: _, ...all } = rest;
+            return { view: all };
+        }
+        default:
+            return { view };
+    }
+}
+/**
+ * A key while a worktree's removal waits for the developer's word. Only `y` goes on, and for a
+ * worktree with uncommitted changes only its name typed out; any other key keeps it.
+ */
+function confirming(view, confirm, key, snapshot) {
+    const { confirm: _, ...rest } = view;
+    const { namespace, suffix } = confirm;
+    const env = snapshot.environments.find((e) => e.namespace === namespace);
+    if (key === "ctrl-c")
+        return { view: { ...rest, quit: true } };
+    if (env === undefined)
+        return { view: rest };
+    const removal = (force) => ({
+        view: rest,
+        intent: { kind: "remove", suffix, namespace, force },
+    });
+    const kept = (why = "") => ({ view: { ...rest, notice: `Kept ${suffix}${why}.` } });
+    if (confirm.step === "remove") {
+        if (typeof key !== "string")
+            return { view };
+        if (key !== "y")
+            return kept();
+        if (!env.changes)
+            return removal(false);
+        return { view: { ...rest, confirm: { ...confirm, step: "discard", typed: "" } } };
+    }
+    const typed = confirm.typed ?? "";
+    switch (key) {
+        case "return":
+            return typed === suffix ? removal(true) : kept(`: the name typed was not ${suffix}`);
+        case "escape":
+            return kept();
+        case "backspace":
+            return {
+                view: { ...view, confirm: { ...confirm, typed: [...typed].slice(0, -1).join("") } },
+            };
+        default: {
+            // A named key (an arrow, page up) is not text.
+            const text = textOf(key);
+            return text === undefined
+                ? { view }
+                : { view: { ...view, confirm: { ...confirm, typed: typed + text } } };
+        }
+    }
+}
+/** A key while a search is typed: text, or `return` to search, or `escape` to cancel. */
+function typing(view, query, key, snapshot) {
+    const { search: _, ...rest } = view;
+    switch (key) {
+        case "ctrl-c":
+            return { ...view, quit: true };
+        case "escape":
+            return rest;
+        case "backspace":
+            return { ...view, search: { query: [...query].slice(0, -1).join(""), typing: true } };
+        case "return": {
+            if (query === "")
+                return rest;
+            const { until: __, ...live } = rest;
+            const found = find({ ...live, search: { query, typing: false } }, -1, snapshot);
+            return found.until === undefined ? { ...live, notice: `No line matches “${query}”.` } : found;
+        }
+        default: {
+            // A named key (an arrow, page up) is not text.
+            const text = textOf(key);
+            return text === undefined ? view : { ...view, search: { query: query + text, typing: true } };
+        }
+    }
+}
+/**
+ * The view at the next line that matches the search, ignoring case: older (`-1`) or newer (`1`)
+ * than the one shown, or the newest when live.
+ */
+function find(view, by, snapshot) {
+    const query = view.search?.query.toLowerCase() ?? "";
+    const lines = streamLines(snapshot, view);
+    const from = view.until === undefined ? lines.length : indexOf(lines, view.until);
+    for (let i = from + by; i >= 0 && i < lines.length; i += by) {
+        const line = lines[i];
+        if (line.text.toLowerCase().includes(query))
+            return { ...view, until: line.seq };
+    }
+    const which = by < 0 ? "older" : "newer";
+    return { ...view, notice: `No ${which} line matches “${view.search?.query}”.` };
+}
+/** A start, stop or restart of one part, or of the whole environment when none is given. */
+function actionOn(env, part, kind) {
+    if (part !== undefined) {
+        const isApp = env.apps.includes(part);
+        return {
+            kind,
+            namespace: ofDaemon(part.id).namespace,
+            apps: isApp ? [part.name] : [],
+            services: isApp ? [] : [part.name],
+            label: part.name,
+        };
+    }
+    // A worktree's services on main's servers are main's: only main's own actions reach them.
+    const services = env.services.filter((s) => ofDaemon(s.id).namespace === env.namespace);
+    if (env.apps.length + services.length === 0)
+        return undefined;
+    return {
+        kind,
+        namespace: env.namespace,
+        apps: env.apps.map((a) => a.name),
+        services: services.map((s) => s.name),
+        label: env.label,
+    };
+}