@turri-dev/cli 0.1.4-next.4342332 → 0.1.4-next.5255d82

package/README.md

@@ -1,4 +1,4 @@
-<p align="center"><img src="docs/images/turri-banner.png" alt="turri - coding agent with the power of regenerative software: regenerate, drift, lineage"></p>
+<p align="center"><img src="docs/images/turri-banner.png" alt="turri - the first coding agent with the power of regenerative software, beside a pixel jellyfish: npm install -g @turri-dev/cli"></p>
 
 <h1 align="center">turri<br>the first coding agent with the power of<br>regenerative software<br>&nbsp;</h1>
 
@@ -101,9 +101,11 @@ With **turri** you work on the durable intent. You say what the software must do
 
 ## How it works
 
+<p align="center"><img src="docs/images/turri-screenshot.png" width="900" alt="turri in the terminal: on the left the conversation, where /regenerate plans a project's modules and a coding agent works through one of them; on the right the spec map of that module's ***plain, each functionality marked as regenerated or being worked on"></p>
+
 **turri** captures the durable intent in [\*\*\*plain](https://plainlang.org/), a language for saying what software should do. \*\*\*plain breaks the intent down into functionalities - small units, each a single thing the software does - and **turri** regenerates the code from them piece by piece.
 
-1. **Define.** Write \*\*\*plain with **turri**
+1. **Define.** You say what the software should do; **turri** writes it down as \*\*\*plain.
 2. **Review and refine.** You review \*\*\*plain and change it with **turri** until it says what you mean.
 3. **Regenerate.** Agents write the code; **turri** decides what they write and when, step by step, the same way every time.
 4. **Validate.** Agents write conformance tests from \*\*\*plain; **turri** runs them, and keeps the code only when it does what \*\*\*plain says.

package/dist/extension.js

@@ -5,7 +5,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { conversationCommand, conversationSettled, conversationWriting } from "./regenerate/conversation-writes.js";
 import { fileURLToPath } from "node:url";
-import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { allocateImageId, Box, getCapabilities, getPngDimensions, isKeyRelease, isKeyRepeat, matchesKey, renderImage, Text, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { CODING_MODEL_ENV } from "./chat-models.js";
@@ -30,9 +30,11 @@ import { checkPlainFile, checkPlainTargets, formatCheckResults } from "./plain/c
 import { whyFailed } from "./regenerate/diagnose-job.js";
 import { createWorkLoop, describeModules, isUpToDate, previewJobs } from "./regenerate/loop.js";
 import { brandNeon, brandPink, plainPaint } from "./regenerate/plain-palette.js";
+import { halfBlocks, JELLYFISH_FRAME_MS, JELLYFISH_TEXT_FRAMES } from "./jellyfish.js";
 import { createJobPanel, didNotPass, keyPressed, PANEL_KEY, spinner } from "./regenerate/job-panel.js";
 import { clickToFocus, dockedWidth, narrowChat, shade, shadeChat } from "./regenerate/panel-dock.js";
 import { overPictureRow, PICTURE_AT } from "./picture-row.js";
+import { padScreen, paddedColumns, paddedRows, SCREEN_PADDING } from "./screen-padding.js";
 import { skillAboutLine, skillProgressLine } from "./skill-progress.js";
 import { createSidePanel } from "./regenerate/side-panel.js";
 import { createSpecMapSource, defaultMapFiles } from "./regenerate/spec-map.js";
@@ -47,7 +49,7 @@ import { inheritProviders, inheritThinkingLevel } from "./pi.js";
 import { beginCapture, captureConsole, describeCaptured, dropNoise } from "./quiet.js";
 import { loadRules, renderRulesBlock } from "./rules.js";
 import { registerTurriConfig } from "./config-command.js";
-import { describeStdlib, stdlibStackCount } from "./stdlib.js";
+import { describeStdlib } from "./stdlib.js";
 import { peekKeyListener, runAsk } from "./ask.js";
 import { QuestionDialog } from "./question-dialog.js";
 import { registerStacks } from "./stacks.js";
@@ -96,7 +98,7 @@ aside) {
                     ...(context !== undefined ? { context } : {}),
                     ...(options !== undefined ? { options } : {}),
                     ...(selected !== undefined ? { selected } : {}),
-                    rows: () => tui.terminal.rows,
+                    rows: () => paddedRows(tui.terminal.rows),
                     style: { accent: (text) => theme.fg("accent", text), muted: (text) => theme.fg("muted", text), bold: (text) => theme.bold(text) },
                     done: (answer) => {
                         if (questionShown === shown)
@@ -370,7 +372,7 @@ export default function (pi) {
         conversationModels = ctx.modelRegistry;
     });
     inheritProviders(() => conversationModels);
-    registerBranding(pi, rules.length, discoveredSkills);
+    registerBranding(pi, discoveredSkills);
     registerInterviewLog(pi);
     registerJobTools(pi, jobs, cwd);
     registerCheckPlain(pi, cwd);
@@ -1526,7 +1528,7 @@ function registerJobTools(pi, jobs, cwd) {
     // The terminal the panel is drawn on, for its width: set as it opens.
     let panelTerminal;
     /** The columns the panel takes beside the chat - 0 over the whole screen, or when the terminal is too narrow to share. */
-    const panelBeside = () => (panelDocked && panelTerminal !== undefined ? dockedWidth(panelTerminal.columns) : 0);
+    const panelBeside = () => (panelDocked && panelTerminal !== undefined ? dockedWidth(paddedColumns(panelTerminal.columns)) : 0);
     // What is open in the pulse list and the map, and where their cursors are: the conversation's, as left each time it opens.
     const jobsTree = createJobsTreeState();
     const mapState = createSpecMapState();
@@ -1584,7 +1586,7 @@ function registerJobTools(pi, jobs, cwd) {
             const layOut = () => {
                 if (panelDocked && undock === undefined) {
                     const widen = narrowChat(tui, panelBeside);
-                    const unwatch = clickToFocus(tui, () => tui.terminal.columns - panelBeside(), (side) => {
+                    const unwatch = clickToFocus(tui, () => tui.terminal.columns - SCREEN_PADDING.right - panelBeside(), (side) => {
                         if (panelBeside() === 0)
                             return;
                         if (side === "chat")
@@ -1625,7 +1627,7 @@ function registerJobTools(pi, jobs, cwd) {
                 tree: jobsTree,
                 map: () => specMap.read(),
                 mapState,
-                rows: () => tui.terminal.rows,
+                rows: () => paddedRows(tui.terminal.rows),
                 key: PANEL_KEY,
                 dock: {
                     docked: () => panelBeside() > 0,
@@ -1756,14 +1758,15 @@ function registerJobTools(pi, jobs, cwd) {
             return component;
         }, {
             overlay: true,
-            // The whole screen, or the columns on the right beside the chat - read at each frame, so it follows the terminal.
+            // The whole screen, or the columns on the right beside the chat - read at each frame, so it follows the terminal -
+            // inside the screen's padding.
             overlayOptions: {
                 get width() {
                     return panelBeside() > 0 ? panelBeside() : "100%";
                 },
                 maxHeight: "100%",
                 anchor: "top-right",
-                margin: 0,
+                margin: { ...SCREEN_PADDING },
             },
             onHandle: (handle) => {
                 if (panel !== undefined)
@@ -2295,7 +2298,7 @@ const BANNER_ENTRY = "turri_banner";
 export function chatRulesBlock(rules = loadRules(join(PACKAGE_ROOT, "genome", "rules"))) {
     return renderRulesBlock(rules);
 }
-function registerBranding(pi, ruleCount, skills) {
+function registerBranding(pi, skills) {
     pi.registerCommand("stdlib", {
         description: "List the ***plain standard library: the stacks a spec can import instead of writing its implementation reqs.",
         handler: async (_args, ctx) => {
@@ -2310,38 +2313,29 @@ function registerBranding(pi, ruleCount, skills) {
         const lines = [
             `${brandPink(theme)("turri")}  ${theme.fg("muted", `v${data.version}`)}` +
                 (data.commit !== undefined ? theme.fg("dim", `  from a clone, ${data.commit}${data.changed ? " with changes" : ""}`) : ""),
-            theme.fg("text", "regenerative software - the code is regenerated from the spec"),
-            theme.fg("muted", `${data.rules} rules · ${data.skills} skill${data.skills === 1 ? "" : "s"}` +
-                (data.projectSkills !== undefined && data.projectSkills > 0 ? ` (${data.projectSkills} the project's)` : "") +
-                (data.stdlib !== undefined && data.stdlib > 0 ? ` · ${data.stdlib} stdlib stacks (/stdlib)` : "") +
-                (data.pending > 0 ? theme.fg("warning", `  (${data.pending} failed to load)`) : "")),
+            theme.fg("text", "the first coding agent with the power of regenerative software"),
             // Where the settings are changed, without leaving the chat.
             theme.fg("muted", "configure with /turri-config"),
-            theme.fg("dim", data.cwd),
-            // Where every command an agent runs will run - or that none can.
-            ...(data.sandbox
-                ? [theme.fg(data.sandbox.level === "ok" ? "dim" : data.sandbox.level === "limited" ? "warning" : "error", data.sandbox.text)]
-                : []),
+            // Only what is wrong: skills that did not load, and agents' commands less fenced than they should be.
+            ...(data.pending > 0 ? [theme.fg("warning", `${data.pending} skill${data.pending === 1 ? "" : "s"} failed to load`)] : []),
+            ...(data.sandbox !== undefined && data.sandbox.level !== "ok" ? [theme.fg(data.sandbox.level === "limited" ? "warning" : "error", data.sandbox.text)] : []),
         ];
         // The jellyfish turri is named after, in ink for the theme's background: a picture where the
         // terminal shows images, drawn in text where it does not.
-        return new Banner(lines, (rule) => theme.fg("borderMuted", rule), jellyfishArt(theme.appearance, (art) => theme.fg("text", art)));
+        return new Banner(lines, (rule) => theme.fg("borderMuted", rule), jellyfishArt(theme.appearance, (theme.getColorMode?.() ?? "truecolor") === "truecolor"));
     });
     pi.on("session_start", (_event, ctx) => {
-        if (ctx.hasUI)
+        if (ctx.hasUI) {
+            padTheScreen(ctx);
             animateJellyfish(ctx);
+        }
         try {
             const identity = turriIdentity();
             pi.appendEntry(BANNER_ENTRY, {
                 version: identity.version ?? "0.0.0",
                 commit: identity.git_commit?.slice(0, 7),
                 changed: identity.git_dirty === true,
-                rules: ruleCount,
-                skills: skills.skills.length,
-                projectSkills: skills.skills.filter((skill) => skill.origin !== "turri").length,
                 pending: skills.pending.length,
-                stdlib: stdlibStackCount(),
-                cwd: ctx.cwd,
                 sandbox: sandboxSummary(),
             });
         }
@@ -2350,10 +2344,8 @@ function registerBranding(pi, ruleCount, skills) {
         }
     });
 }
-/** How many rows the banner's jellyfish takes: taller than the lines beside it. */
-const JELLYFISH_ROWS = 13;
-/** How long each frame of the jellyfish shows. */
-const JELLYFISH_FRAME_MS = 250;
+/** How many rows the banner's jellyfish takes at most: as tall as the one drawn in text. */
+const JELLYFISH_ROWS = 10;
 /** Which frame of the jellyfish every banner shows, moved on by `animateJellyfish`. */
 let jellyfishFrame = 0;
 let jellyfishTimer;
@@ -2388,6 +2380,24 @@ function animateJellyfish(ctx) {
     }, { placement: "belowEditor" });
 }
 const JELLYFISH_CLOCK_KEY = "turri-jellyfish";
+/**
+ * The whole screen inside its padding (`screen-padding.ts`). An extension is given pi's screen only through what it
+ * draws, so an empty widget below the editor hands it over - at each frame, as pi starts a new screen when it changes
+ * how it draws.
+ */
+function padTheScreen(ctx) {
+    ctx.ui.setWidget(SCREEN_PADDING_KEY, (tui) => {
+        padScreen(tui);
+        return {
+            render: () => {
+                padScreen(tui);
+                return [];
+            },
+            invalidate: () => { },
+        };
+    }, { placement: "belowEditor" });
+}
+const SCREEN_PADDING_KEY = "turri-padding";
 /** The columns the banner's picture takes from the left edge, while it shows one; 0 when it does not. */
 let pictureRight = 0;
 /**
@@ -2446,7 +2456,7 @@ class Banner {
             return line !== undefined ? `${before}${line}` : placed?.kind === "text" ? ` ${jellyfish}` : "";
         });
         // The side panel is drawn beside the picture (drawOverlaysBesidePicture), which goes on showing.
-        pictureRight = placed?.kind === "image" ? 1 + placed.columns : 0;
+        pictureRight = placed?.kind === "image" ? SCREEN_PADDING.left + 1 + placed.columns : 0;
         if (placed?.kind === "image") {
             const at = placed.onLastRow ? placed.rows - 1 : 0;
             rows[at] = `${rows[at]}${PICTURE_AT}${placed.sequence}`;
@@ -2473,24 +2483,16 @@ class Banner {
 }
 const jellyfishFrameCache = new Map();
 /**
- * The banner's jellyfish for this terminal: where it shows images, the picture's frames spread evenly
- * over the video, light ink for a dark background and dark ink for a light one; where it does not, the
- * jellyfish drawn in text, in `ink`. None when they cannot be read.
+ * The banner's jellyfish for this terminal: where it shows images, the picture's frames
+ * (scripts/jellyfish-frames.mjs writes them), in the colours for the theme's background; where it does not, the
+ * small one in half blocks. None when the pictures cannot be read.
  */
-function jellyfishArt(appearance, ink) {
+function jellyfishArt(appearance, truecolor) {
     const dir = join(PACKAGE_ROOT, "assets", "jellyfish");
     try {
         if (getCapabilities().images === null) {
-            // Its frames one after another, each ended by a line of "---" (scripts/jellyfish-frames.mjs writes them).
-            const drawn = readFileSync(join(dir, "fallback.txt"), "utf8")
-                .split(/^---$/m)
-                .map((frame) => frame.replace(/^\n+|\n+$/g, "").split("\n"))
-                .filter((frame) => frame.some((line) => line.trim() !== ""));
-            if (drawn.length === 0)
-                return undefined;
-            const columns = Math.max(...drawn.flat().map((line) => visibleWidth(line)));
-            const rows = Math.max(...drawn.map((frame) => frame.length));
-            return { kind: "text", frames: drawn.map((frame) => frame.map((line) => ink(line.padEnd(columns)))), columns, rows };
+            const frames = JELLYFISH_TEXT_FRAMES.map((pixels) => halfBlocks(pixels, appearance, truecolor));
+            return { kind: "text", frames, columns: JELLYFISH_TEXT_FRAMES[0][0].length, rows: frames[0].length };
         }
         let frames = jellyfishFrameCache.get(appearance);
         if (frames === undefined) {

package/dist/jellyfish.js

@@ -0,0 +1,130 @@
+import { sgr } from "./regenerate/plain-palette.js";
+/** The pixels' colours on a dark background and a light one - the tentacles darker on light, where neon does not show. */
+export const JELLYFISH_COLOURS = {
+    dark: { p: "#ff5c8d", h: "#ff7fa6", w: "#f4f7f9", o: "#ff7a3d", e: "#732553", N: "#8eebee", n: "#5ce1e6", l: "#85a3b2", g: "#3e5a6b" },
+    light: { p: "#ff5c8d", h: "#ff7fa6", w: "#f4f7f9", o: "#ff7a3d", e: "#732553", N: "#3e5a6b", n: "#1e3442", l: "#85a3b2", g: "#85a3b2" },
+};
+/**
+ * How shut the bell is, frame by frame - a quarter second each: shut quickly, held a moment, opened slowly, at rest
+ * until the next stroke.
+ */
+const SHUT = [0.1, 0.55, 0.9, 1, 0.85, 0.7, 0.56, 0.44, 0.33, 0.23, 0.14, 0.06];
+const LARGE = {
+    width: 24,
+    height: 26,
+    open: [6, 12, 16, 18, 20, 22, 22, 24, 24],
+    shut: [6, 10, 14, 16, 18, 18, 18, 20, 20],
+    glint: [[-3, 2], [-4, 2], [-5, 3], [-6, 4], [-6, 5]],
+    shine: [-2, 2],
+    gut: [".oo..oo.", "oooooooo", "oooooooo", ".oo..oo."],
+    gutRow: 4,
+    strands: [
+        { at: -8, length: 10, sway: 1.1, ink: "N" },
+        { at: -4.5, length: 13, sway: 1.3, ink: "N" },
+        { at: -1, length: 14, sway: 0.8, ink: "n" },
+        { at: 2, length: 13, sway: 0.8, ink: "n" },
+        { at: 5.5, length: 13, sway: 1.3, ink: "N" },
+        { at: 9, length: 10, sway: 1.1, ink: "N" },
+    ],
+};
+const SMALL = {
+    width: 18,
+    height: 20,
+    open: [4, 10, 12, 14, 16, 18, 18],
+    shut: [4, 8, 10, 12, 14, 14, 14],
+    glint: [[-2, 1], [-3, 2], [-4, 3]],
+    shine: [-1, 1],
+    gut: ["oo..oo", "oooooo", "oo..oo"],
+    gutRow: 3,
+    strands: [
+        { at: -6, length: 8, sway: 0.9, ink: "N" },
+        { at: -3, length: 10, sway: 1, ink: "N" },
+        { at: -0.5, length: 11, sway: 0.7, ink: "n" },
+        { at: 1.5, length: 10, sway: 0.7, ink: "n" },
+        { at: 4, length: 10, sway: 1, ink: "N" },
+        { at: 7, length: 8, sway: 0.9, ink: "N" },
+    ],
+};
+/** One frame of a design: its height in rows of its width in pixels, "." where there is none. */
+function frame(design, t) {
+    const grid = Array.from({ length: design.height }, () => Array(design.width).fill("."));
+    const centre = design.width / 2;
+    const set = (y, x, pixel, over = true) => {
+        if (y < 0 || y >= design.height || x < 0 || x >= design.width)
+            return;
+        if (over || grid[y][x] === ".")
+            grid[y][x] = pixel;
+    };
+    const shut = SHUT[t % SHUT.length];
+    // Shut, it has risen a pixel.
+    const top = shut > 0.6 ? 0 : 1;
+    const widths = design.open.map((open, row) => 2 * Math.round((open - (open - design.shut[row]) * shut) / 2));
+    widths.forEach((width, row) => {
+        for (let x = centre - width / 2; x < centre + width / 2; x++)
+            set(top + row, x, "p");
+    });
+    const rimWidth = widths.at(-1);
+    const rim = top + widths.length;
+    // The underside along the bottom row, the rim scalloped under it.
+    for (let x = centre - rimWidth / 2 + 2; x < centre + rimWidth / 2 - 2; x++)
+        set(rim - 1, x, "e");
+    for (let x = centre - rimWidth / 2; x < centre + rimWidth / 2; x += 2)
+        set(rim, x + 1, "p");
+    // A glint up on the left, curving with the dome, and a pixel of shine.
+    for (const [dx, dy] of design.glint)
+        set(top + dy, centre + dx, "h");
+    set(top + design.shine[1], centre + design.shine[0], "w");
+    const gutLeft = centre - Math.floor(design.gut[0].length / 2);
+    design.gut.forEach((line, dy) => [...line].forEach((pixel, dx) => pixel === "o" && set(top + design.gutRow + dy, gutLeft + dx, "o")));
+    // The tentacles: rooted under the bell, drawn in as it shuts, swaying - the further down, the later.
+    const phase = (2 * Math.PI * t) / SHUT.length;
+    design.strands.forEach((strand, i) => {
+        const root = centre - 0.5 + strand.at * (rimWidth / design.open.at(-1));
+        for (let y = 0; y < strand.length; y++) {
+            const x = Math.round(root + strand.sway * Math.sin(phase - y * 0.55 + i * 0.8) * Math.min(1, y / 3));
+            const left = strand.length - y;
+            // The tips come apart, every other pixel, fading - into code.
+            if (left <= 3 && y % 2 === 1)
+                continue;
+            set(rim + 1 + y, x, left > 5 ? strand.ink : left > 2 ? "l" : "g", false);
+            // The oral arms are frilled.
+            if (strand.ink === "n" && left > 5 && (y + t) % 3 === 0)
+                set(rim + 1 + y, x + (strand.at < 0 ? -1 : 1), "n", false);
+        }
+    });
+    return grid.map((row) => row.join(""));
+}
+export const JELLYFISH_WIDTH = LARGE.width;
+export const JELLYFISH_HEIGHT = LARGE.height;
+/** The large jellyfish's frames, a stroke: what the pictures are rendered from. */
+export const JELLYFISH_FRAMES = SHUT.map((_, t) => frame(LARGE, t));
+/** The small jellyfish's frames, a stroke: what a terminal without images draws, in half blocks. */
+export const JELLYFISH_TEXT_FRAMES = SHUT.map((_, t) => frame(SMALL, t));
+/** How long each frame shows. */
+export const JELLYFISH_FRAME_MS = 250;
+/**
+ * A frame drawn in half blocks for a terminal that shows no images: two pixels a cell, the upper one the text's colour
+ * and the lower one the background's, in as many colours as the terminal has: a column a pixel, a row every two.
+ */
+export function halfBlocks(pixels, appearance, truecolor) {
+    const colours = JELLYFISH_COLOURS[appearance];
+    const colour = (pixel) => (pixel === undefined || pixel === "." ? undefined : colours[pixel]);
+    const rows = [];
+    for (let y = 0; y < pixels.length; y += 2) {
+        let row = "";
+        for (let x = 0; x < (pixels[0]?.length ?? 0); x++) {
+            const upper = colour(pixels[y]?.[x]);
+            const lower = colour(pixels[y + 1]?.[x]);
+            if (upper === undefined && lower === undefined)
+                row += " ";
+            else if (upper === undefined)
+                row += `\x1b[${sgr(lower, false, truecolor)}m▄\x1b[39m`;
+            else if (lower === undefined)
+                row += `\x1b[${sgr(upper, false, truecolor)}m▀\x1b[39m`;
+            else
+                row += `\x1b[${sgr(upper, false, truecolor)};${sgr(lower, true, truecolor)}m▀\x1b[39;49m`;
+        }
+        rows.push(row);
+    }
+    return rows;
+}

package/dist/picture-row.js

@@ -1,6 +1,7 @@
 import { compositeTuiLine } from "@earendil-works/pi-tui";
-/** What the banner puts between a row's text and the picture after it: back to the jellyfish's column. */
-export const PICTURE_AT = "\x1b[2G";
+import { SCREEN_PADDING } from "./screen-padding.js";
+/** What the banner puts between a row's text and the picture after it: back to the jellyfish's column, a column in from the screen's padding. */
+export const PICTURE_AT = `\x1b[${SCREEN_PADDING.left + 2}G`;
 /** The picture's escape sequence, as the banner writes it after PICTURE_AT: Kitty's, in chunks, or iTerm2's - climbing first on iTerm2. */
 const PICTURE = /^(?:\x1b\[\d+A)?(?:(?:\x1b_G[^\x1b]*\x1b\\)+|\x1b\]1337;File=[^\x07]*\x07)/;
 /**

package/dist/regenerate/panel-dock.js

@@ -1,15 +1,16 @@
 import { HStack } from "@earendil-works/pi-tui";
+import { unpadded } from "../screen-padding.js";
 /**
  * The side panel beside the chat rather than over it: the chat drawn on the left in what the panel leaves it, the panel
  * laid over the columns on the right.
  *
  * pi draws its screen one of two ways, and the chat is narrowed in each as it is drawn: full screen (pi's default), a
  * layout - its root put in a row beside a filler as wide as the panel; the regular screen, the lines its render gives -
- * asked for in fewer columns.
+ * asked for in fewer columns. Either way inside the screen's padding (`screen-padding.ts`), when it has one.
  */
 /** Narrower than this, the chat and the panel have no room side by side: the panel takes the whole screen. */
 const SHARED_FROM = 100;
-/** The columns the panel takes beside the chat: half the screen, the rule between them in the middle - 0 when the terminal is too narrow to share. */
+/** The columns the panel takes beside the chat: half of what they share, the rule between them in the middle - 0 when that is too narrow to share. */
 export function dockedWidth(columns) {
     return columns < SHARED_FROM ? 0 : Math.floor(columns / 2);
 }
@@ -20,14 +21,15 @@ export function dockedWidth(columns) {
 export function narrowChat(tui, panelWidth) {
     const screen = tui;
     if (typeof screen.setLayoutRoot === "function" && screen.layoutRoot !== undefined) {
-        const root = screen.layoutRoot;
+        // What the padding pads: the row goes inside it, and is padded as it is set.
+        const root = unpadded(screen.layoutRoot);
         // A line as wide as the panel: the row gives the filler what it measures, the chat the rest.
         const filler = { render: () => [" ".repeat(panelWidth())], invalidate() { } };
         screen.setLayoutRoot(new HStack([{ component: root, basis: 0, grow: 1 }, { component: filler }]));
         return () => screen.setLayoutRoot(root);
     }
-    // Read from the prototype: the screen's own render, not one laid over it.
-    const render = Object.getPrototypeOf(tui).render;
+    // The render the screen has now - padded, when it is.
+    const render = screen.render;
     screen.render = function (width) {
         return render.call(this, Math.max(1, width - panelWidth()));
     };

package/dist/regenerate/plain-palette.js

@@ -47,7 +47,7 @@ const rgb = (hex) => {
     return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
 };
 /** A colour's SGR parameters: 24-bit, or the nearest of the 256 where the terminal has no more. */
-function sgr(hex, background, truecolor) {
+export function sgr(hex, background, truecolor) {
     const [r, g, b] = rgb(hex);
     if (truecolor)
         return `${background ? 48 : 38};2;${r};${g};${b}`;

package/dist/screen-padding.js

@@ -0,0 +1,72 @@
+import { HStack, Spacer, VStack } from "@earendil-works/pi-tui";
+/**
+ * Room around the whole of turri's screen: a row above and below, two columns either side - a cell is about twice as
+ * tall as it is wide.
+ *
+ * pi draws its screen one of two ways, and each is padded as it is drawn: full screen (pi's default), a layout - its
+ * root put in the middle of blank rows and columns; the regular screen, the lines its render gives - asked for in fewer
+ * columns, indented, with blank lines above and below. Overlays are laid over the whole terminal, so one that should
+ * keep to the padding is given it as its margin.
+ */
+export const SCREEN_PADDING = { top: 1, right: 2, bottom: 1, left: 2 };
+/** The columns inside the padding. */
+export function paddedColumns(columns) {
+    return Math.max(1, columns - SCREEN_PADDING.left - SCREEN_PADDING.right);
+}
+/** The rows inside the padding. */
+export function paddedRows(rows) {
+    return Math.max(1, rows - SCREEN_PADDING.top - SCREEN_PADDING.bottom);
+}
+/** Each padded layout root, to what it pads. */
+const content = new WeakMap();
+/** What a layout root pads - the root itself when it is not padded. */
+export function unpadded(root) {
+    return content.get(root) ?? root;
+}
+/** A blank column as wide as the padding on its side: the row gives it what it measures. */
+const blankColumns = (columns) => ({ render: () => [" ".repeat(columns)], invalidate() { } });
+function padded(root) {
+    const row = new HStack([
+        { component: blankColumns(SCREEN_PADDING.left), basis: SCREEN_PADDING.left },
+        { component: root, basis: 0, grow: 1 },
+        { component: blankColumns(SCREEN_PADDING.right), basis: SCREEN_PADDING.right },
+    ]);
+    const whole = new VStack([
+        { component: new Spacer(SCREEN_PADDING.top), basis: SCREEN_PADDING.top },
+        // As pi lays out its own transcript: the rows the padding leaves, whatever it measures.
+        { component: row, basis: 0, grow: 1, minSize: 1 },
+        { component: new Spacer(SCREEN_PADDING.bottom), basis: SCREEN_PADDING.bottom },
+    ]);
+    content.set(whole, root);
+    return whole;
+}
+/**
+ * pi's screen drawn inside the padding, from its next frame - and every layout root it is given after, so the chat
+ * narrowed beside the docked panel (`narrowChat`) is padded too. Once a screen: pi starts a new one when it changes how
+ * it draws, which is padded when it is passed in.
+ */
+export function padScreen(tui) {
+    const screen = tui;
+    if (screen.turriPadded === true)
+        return;
+    if (typeof screen.setLayoutRoot === "function") {
+        // Full screen before pi has given it its layout: padded at a later frame.
+        if (screen.layoutRoot === undefined)
+            return;
+        screen.turriPadded = true;
+        const set = screen.setLayoutRoot;
+        screen.setLayoutRoot = function (root) {
+            set.call(this, root === undefined ? undefined : padded(unpadded(root)));
+        };
+        screen.setLayoutRoot(screen.layoutRoot);
+        return;
+    }
+    screen.turriPadded = true;
+    // Read from the prototype: the screen's own render, not one laid over it.
+    const render = Object.getPrototypeOf(tui).render;
+    const left = " ".repeat(SCREEN_PADDING.left);
+    screen.render = function (width) {
+        const lines = render.call(this, paddedColumns(width)).map((line) => `${left}${line}`);
+        return [...new Array(SCREEN_PADDING.top).fill(""), ...lines, ...new Array(SCREEN_PADDING.bottom).fill("")];
+    };
+}

package/docs/development.md

@@ -54,6 +54,7 @@ The workflow signs in to npm with npm's trusted publishing (OIDC), not a token:
 | `src/regenerate/engine.ts` | choosing and resolving render models |
 | `src/regenerate/job-panel.ts`, `src/regenerate/transcript-view.ts`, `src/regenerate/diff-view.ts` | the job panel, the side panel's colours, and a spec diff as they show it - highlighted and banded |
 | `src/regenerate/side-panel.ts`, `src/regenerate/panel-dock.ts` | the side panel, and the chat narrowed beside it when it is docked |
+| `src/screen-padding.ts` | the blank row above and below the whole screen and the two columns either side, in both of pi's ways of drawing it |
 | `src/regenerate/spec-map.ts`, `src/regenerate/spec-map-view.ts` | regen: each item's mark, from the records, the `.plain` files and the work loop's plan (`mapPlan`), and the map drawn |
 | `src/regenerate/debug-log.ts` | each render agent's whole conversation, always streamed to `.turri/debug/` |
 | `genome/` | what turri knows and can do: `genome/skills/`, the skill library, and `genome/rules/`, the \*\*\*plain authoring rules |

package/docs/theming.md

@@ -25,14 +25,14 @@ Both themes, the command line's colours, the spec diff's, the banner's jellyfish
 | lines | `#22344a` | rules, dividers, frames: `borderMuted`, `mdHr` |
 | path | `#3e5a6b` | the editor's border, what is dim: `dim`, line numbers |
 | grauzone | `#85a3b2` | body text, and what can be skimmed: `text`, `muted` |
-| white | `#f4f7f9` | headings, tool titles, what you typed, the jellyfish |
+| white | `#f4f7f9` | headings, tool titles, what you typed, the jellyfish's shine |
 | siesta tan | `#e9d8c8` | inline code, \*\*\*plain's text in quotes or backticks |
 | eggplant | `#732553` | a removed line's fill in a spec diff |
 | neon | `#5ce1e6` | links, focus, the selection, section labels, \*\*\*plain's concepts in a spec diff: `accent`, `mdLink`, regen's `◆` |
 | neon hover | `#8eebee` | types in code, an added line's fill in a light theme's spec diff |
-| pink | `#ff5c8d` | the wordmark, and what is done - its `✓`, the spec map's `◇` and `◆`: `success` |
+| pink | `#ff5c8d` | the wordmark, the jellyfish's bell, and what is done - its `✓`, the spec map's `◇` and `◆`: `success` |
 | pink hover | `#ff7fa6` | \*\*\*plain's section headers, a removed line's `-`, keywords in code |
-| orange | `#ff7a3d` | the `$` of bash mode, and everything that asks for you - what failed (`✗`), what works with limits, what needs you (the spec map's `!`): `error`, `warning` |
+| orange | `#ff7a3d` | the jellyfish's gut, the `$` of bash mode, and everything that asks for you - what failed (`✗`), what works with limits, what needs you (the spec map's `!`): `error`, `warning` |
 
 The design system keeps pink for the one thing to press and orange for the `$` prompt alone. A terminal has no buttons, but it needs status colours, so pink carries what is done and orange everything that asks for you - what failed, what works with limits, what waits on you - the mark (`✗`, `!`, `■`) telling them apart. The palette has no red.
 

package/docs/using.md

@@ -7,7 +7,7 @@ cd ~/my-project
 turri
 ```
 
-That is pi, with turri's tools, skills and themes loaded - `turri` alone, or with pi's options (`turri -c`, `turri --harness-model <m>`). It opens with turri's own banner - the jellyfish it is named after, swimming until the conversation fills the screen: a picture in a terminal that shows images (Kitty, Ghostty, WezTerm, Warp, iTerm2), and drawn in text in any other, tmux included - swimming a stroke a loop, its tentacles following its bell, frames `scripts/jellyfish-frames.mjs` writes - turri's version (and, run from a clone, the commit it is on, and whether the clone has changes), where commands will run, the rules and skills loaded - rather than pi's startup header and resource list; `turri --verbose` shows those too. pi's "Update Available" notice is left out - turri's pi is a pinned dependency `pi update` never touches - and the terminal's tab reads `🪼 turri - <folder>`, not pi's `π`. Talk to it: ask it to start a project, add a feature, render a module, fix a spec. It decides which skill or tool applies - but not *how* a skill runs: `cultivate` hands the work to the gated runner, which owns the steps, the gates and the judges (see [skills and gates](skills-and-gates.md)).
+That is pi, with turri's tools, skills and themes loaded - `turri` alone, or with pi's options (`turri -c`, `turri --harness-model <m>`). It opens with turri's own banner - the jellyfish it is named after, swimming until the conversation fills the screen: a pixel jellyfish - a pink bell, an orange gut, neon tentacles coming apart into code at their tips - swimming a stroke a loop, its bell shutting and rising, its tentacles following: a picture in a terminal that shows images (Kitty, Ghostty, WezTerm, Warp, iTerm2), and drawn smaller in half blocks in any other, tmux included (`src/jellyfish.ts` draws it, `scripts/jellyfish-frames.mjs` writes the pictures) - turri's version (and, run from a clone, the commit it is on, and whether the clone has changes) and where its settings are changed - and only when something is wrong, skills that failed to load or agents' commands less fenced than they should be - rather than pi's startup header and resource list; `turri --verbose` shows those too. pi's "Update Available" notice is left out - turri's pi is a pinned dependency `pi update` never touches - and the terminal's tab reads `🪼 turri - <folder>`, not pi's `π`. Talk to it: ask it to start a project, add a feature, render a module, fix a spec. It decides which skill or tool applies - but not *how* a skill runs: `cultivate` hands the work to the gated runner, which owns the steps, the gates and the judges (see [skills and gates](skills-and-gates.md)).
 
 The skills that build from scratch:
 
@@ -58,7 +58,7 @@ A render takes minutes, so in the TUI every render tool starts the work as a pul
 - **The panel** above the input, while something runs, shows on top what finished - a line a module, its pulses oldest first, each with its mark (green, red or amber, as in the side panel), number and kind - what it regenerated is in the side panel - `cognio  … 2 earlier · ✓ 3 regenerate · ✓ 4 conformance`, the newest that fit the width - then a rule, and under it each running pulse - `cognio · regenerate pulse 5`, `cognio · conformance pulse 6` - its time and cost, and what its agents are doing. A module whose work is being planned into pulses shows at once, before any pulse runs - `shorty · planning the pulses · 12s` - the planner is an agent, and takes a while; a `/regenerate` says it began the moment it is sent. Pulses are numbered within their module, as regen numbers them. `ctrl+o` expands the agents' trace alone; what finished stays a line a module. The line of keys under it - `ctrl+o to expand the trace · ctrl+h to peek at regen` - has each key breathing, fully there to a little faint and back, until it is first pressed: once `ctrl+o` has opened the trace, or the side panel has been opened, that key is still for the rest of the session and the other breathes on. What waits is not in it, and it shows no spec diff - the side panel has both. With nothing running it is gone.
 - **A pulse's change** is what its agent works from, not a text diff of the module's file: the items `<spec change>` gives the agent - only what the pulse's functional specs use, an import's items as well as the module's own, a code pulse's without the test reqs - each in the file it is written in, under its section, in the file's order (`change-view.ts`).
 - **A spec diff**, in the side panel, reads as an editor shows a diff: its \*\*\*plain highlighted as [plyn](https://github.com/plainlang/plyn) highlights it - section headers, concepts, names in backticks, text in quotes, links, the front matter - each added line filled green and each removed one red, the text on top, the fill the width of the panel ([colours](theming.md#spec-diffs)). It is shown file by file, each file's lines together under its name, with what it adds and takes out - the module being rendered first, the rest by name, and none the diff does not change. Each line has its number in that file: a spec diff is of the spec as read, with what it imports laid in, so a line is placed in the file it is written in - its links read as the parser renders them - and a removed line, in no file now, goes with the change it is part of and has no number. A line is never put in a file on a guess: one that cannot be placed is listed last, under "not found in the spec's files". Where lines of a file are not in the diff, `↕ 28 lines` says how many, as GitHub does - `↑` above the first - and names the section the lines under it are in when it is another than the one above, `↕ 28 lines · ***functional specs***`, as GitHub names a hunk's function: each section is named once.
-- **The side panel** (`ctrl+h`, as it was left - but on the pulse that last failed, stopped or did not pass, when one has since it was last opened: the live panel that showed it is gone with the last pulse, and its announcement in the chat says `ctrl+h shows this pulse`; **`/pulses`** on the pulses; not `ctrl+j`, which a terminal without the Kitty keyboard protocol sends as a line feed, the same as `shift+enter`, and which a dialog takes for `enter`; both stay pi's new-line keys. `ctrl+h` is the byte old terminals sent for backspace; a terminal set to send `^H` for its Backspace key would open the panel on it) takes the whole screen - the panel or the chat, one at a time - or, `s`, sits beside the chat: the chat on the left, the panel in the right half of the screen, and `s` again over the whole screen. It opens as it was last left, for the conversation; a terminal under 100 columns has no room for both and shows the panel over the whole screen. It opens on **regen**: the spec itself, in full, with how much of it the code has been regenerated from drawn onto it.
+- **The side panel** (`ctrl+h`, as it was left - but on the pulse that last failed, stopped or did not pass, when one has since it was last opened: the live panel that showed it is gone with the last pulse, and its announcement in the chat says `ctrl+h shows this pulse`; **`/pulses`** on the pulses; not `ctrl+j`, which a terminal without the Kitty keyboard protocol sends as a line feed, the same as `shift+enter`, and which a dialog takes for `enter`; both stay pi's new-line keys. `ctrl+h` is the byte old terminals sent for backspace; a terminal set to send `^H` for its Backspace key would open the panel on it) takes the whole screen - the panel or the chat, one at a time - or, `s`, sits beside the chat: the chat on the left, the panel in the right half of the screen, and `s` again over the whole screen. It opens as it was last left, for the conversation; a terminal under 104 columns - 100 inside the screen's padding, a blank row above and below everything and two columns either side - has no room for both and shows the panel over the whole screen. It opens on **regen**: the spec itself, in full, with how much of it the code has been regenerated from drawn onto it.
 
   Every item of the spec - a definition, a req, a functional spec with its sub-bullets and acceptance tests, what turri plans and diffs by - is a row in the file's order, its \*\*\*plain highlighted as plyn highlights it (as a spec diff is) and wrapped to the width, never cut short. The map has two columns, each headed on the line over it with a line of space under it: **status**, a mark a row - its rung on a ladder every item climbs - and the module's file, its spec. The top of the panel is where it is seen first: the top line, the module tabs, and the keys - each view's, `d talk it through in the chat` first when the module needs you - wrapped, never cut short, a line of space between the top line and the keys; then straight under them a rule, a line of space, and the columns' headings. The pulses view has its keys at the top too, and a line of space under its rule. The legend is a box of its own in the upper right corner, over what is under it, a line a mark, up the ladder. It names every rung, whatever the page shows - to take out only where something is - and a panel under 60 columns wide has none.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.4-next.4342332",
+  "version": "0.1.4-next.5255d82",
   "license": "MIT",
   "type": "module",
   "repository": {

package/assets/jellyfish/fallback.txt

@@ -1,252 +0,0 @@
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) )  ║║ ╱ ) )
-      (  ╱ ╱ ╱╱ (  ( )
-     ╱ ╱ ) ))  )  )  )
-   ╱ (  ( ) ⁏  )  )  (
- )  ⁏  )  ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &   .
----
-
-           ▄▆▆██▆▆▄
-        ▄▆█▓▒░░░░▒▓█▆▄
-      ▄█▓▒░ ░▒▒▒▒░ ░▒▓█▄
-     ▐█▒░ ░▒▓████▓▒░ ░▒█▌
-     ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) ) ║║ ) )  )
-       ( ( ( (╱ ( (  (
-      ╱ ╱ ╱ ╱  ) )  )
-    ╱ ( ) ) ⁏ )  )  )
-  )  ⁏  ) ⁏ @ )  ⁏  ╱
-  ⁏ $  ⁏  ;   ⁏ * ⁏
-  #    %    &   .
----
-            ▄▆██▆▄
-         ▄▆█▓▒░░▒▓█▆▄
-       ▄█▓▒░░▒▓▓▒░░▒▓█▄
-      ▐█▒░░▒▓████▓▒░░▒█▌
-      ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-        ) ) ) ║║ ) ) )
-       ( ( ( (( ( ( )
-      ) ) ) )) ) )  )
-     ╱ ╱ ( (⁏ )  ) )
-   ) ⁏  ) ⁏ @ )  ⁏ ╱
-   ⁏ $  ⁏ ;   ⁏ *⁏
-  #     %   &   .
-
----
-            ▄▆██▆▄
-         ▄▆█▓▒░░▒▓█▆▄
-       ▄█▓▒░░▒▓▓▒░░▒▓█▄
-      ▐█▒░░▒▓████▓▒░░▒█▌
-      ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-        ) ) ) ║║ ) ) )
-       ( ( ) (( ( )  (
-      ) )  ))) )  ) )
-      ╱ ╱ ( (⁏ ( ( )
-    ) ⁏  ) ⁏@ ) ⁏  )
-   ⁏  $ ⁏ ;   ⁏ * ⁏
-   #    %   &   .
-
----
-            ▄▆██▆▄
-         ▄▆█▓▒░░▒▓█▆▄
-       ▄█▓▒░░▒▓▓▒░░▒▓█▄
-      ▐█▒░░▒▓████▓▒░░▒█▌
-      ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-        ) ) ) ║║ ) ) )
-       ( ) ) )) ) )  (
-      )  ) ) )) ) ) )
-      ( ( ( (⁏ ( ( )
-     ) ⁏ ) ⁏@ ) ⁏  )
-    ⁏ $  ⁏ ;  ⁏ * ⁏
-   #    %   &   .
-
----
-            ▄▆██▆▄
-         ▄▆█▓▒░░▒▓█▆▄
-       ▄█▓▒░░▒▓▓▒░░▒▓█▄
-      ▐█▒░░▒▓████▓▒░░▒█▌
-      ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-        ) ) ) ║║ ) ) )
-       ( ( ) )) ( ) )
-      ) )  ) )))  ) )
-      ( ( ( (⁏ ( ( )
-     ) ⁏ ) ⁏@ ) ⁏  )
-    ⁏ $  ⁏ ;  ⁏ * ⁏
-   #    %    &   .
-
----
-            ▄▆██▆▄
-         ▄▆█▓▒░░▒▓█▆▄
-       ▄█▓▒░░▒▓▓▒░░▒▓█▄
-      ▐█▒░░▒▓████▓▒░░▒█▌
-      ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-        ) ) ) ║║ ) ) )
-       ( (  ((( ( ) )
-      ) )  ))) )  ) )
-     )  ( ( (⁏ ( ( )
-     ) ⁏ ) ⁏@ ) ⁏  )
-    ⁏ $  ⁏ ;  ⁏ * ⁏
-    #   %    &   .
-
----
-
-           ▄▆▆██▆▆▄
-        ▄▆█▓▒░░░░▒▓█▆▄
-      ▄█▓▒░ ░▒▒▒▒░ ░▒▓█▄
-     ▐█▒░ ░▒▓████▓▒░ ░▒█▌
-     ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) ) ║║ )  ) )
-       ( ( ( (( (  ( )
-      ) ) ) )) )  )  )
-     ( ( ) ) ⁏ (  ( (
-    ) ⁏  ) ⁏@ )  ⁏ )
-   ⁏  $ ⁏ ;   ⁏ *  ⁏
-   #    %    &    .
----
-
-           ▄▆▆██▆▆▄
-        ▄▆█▓▒░░░░▒▓█▆▄
-      ▄█▓▒░ ░▒▒▒▒░ ░▒▓█▄
-     ▐█▒░ ░▒▓████▓▒░ ░▒█▌
-     ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) ) ║║ ) )  )
-       ( ( ( (( ( )  )
-      ╱ ) ) )) )  )  )
-    )  ( ) )⁏  (  ( )
-    ) ⁏  ) ⁏@ )  ⁏  )
-   ⁏ $  ⁏ ;   ⁏ *  ⁏
-   #    %    &    .
----
-
-           ▄▆▆██▆▆▄
-        ▄▆█▓▒░░░░▒▓█▆▄
-      ▄█▓▒░ ░▒▒▒▒░ ░▒▓█▄
-     ▐█▒░ ░▒▓████▓▒░ ░▒█▌
-     ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) ) ║║ ) )  )
-       ( ( ( (( ( )  (
-      ╱ ) ) )) )  ) )
-    (  ( ( )⁏  ( )  )
-   )  ⁏ )  ⁏@ )  ⁏  )
-   ⁏ $  ⁏ ;   ⁏ *  ⁏
-  #     %    &    .
----
-
-           ▄▆▆██▆▆▄
-        ▄▆█▓▒░░░░▒▓█▆▄
-      ▄█▓▒░ ░▒▒▒▒░ ░▒▓█▄
-     ▐█▒░ ░▒▓████▓▒░ ░▒█▌
-     ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) )  ║ ) )  )
-       ( ( ( (( ( )  (
-      ╱ ╱ ) )) )  ) )
-    ( )  ( )⁏  ( )  )
-   )  ⁏ )  ⁏@ )  ⁏  )
-   ⁏ $  ⁏ ;   ⁏ *  ⁏
-  #     %    &   .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-      )  )  )  ║  ╱ ) )
-      (  ╱ ( (( (  ( )
-     ╱ )  ╱ )) )  )  )
-   (  ( )  (⁏  )  )  (
-  )  ⁏  ) ⁏ @  )  ⁏ )
-  ⁏ $   ⁏ ;   ⁏  * ⁏
- #     %     &    .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-      )  )  )  ║║ ╱ ) )
-      (  ╱ ( (( (  ( )
-     ╱ )  ╱ )) )  )  )
-   (  ( )  (⁏  )  )  (
-  )  ⁏  ) ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &    .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) )  ║║ ╱ ) )
-      (  ╱ ( (( (  ( )
-     ╱ )  ╱ )) )  )  )
-   (  ( )  (⁏  )  )  (
-  )  ⁏  ) ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &    .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) )  ║║ ╱ ╱ )
-      (  ╱ ╱ ╱╱ ( )  )
-     ╱ ╱ ) ))  )  )  )
-   ( (  ( ) ⁏  )  )  (
-  ) ⁏  )  ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &    .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  )  ╱ ║║ ╱ ╱ )
-      (  ╱ ╱ ╱╱ ( )  )
-     ╱ ╱ ) ))  )  )  )
-   ( (  ( ) ⁏  )  )  (
-  ) ⁏  )  ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &    .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  )  ╱ ║║ ╱ ╱ )
-      (  ╱ ╱ ╱╱ ( )  )
-     ╱ ╱ ) ))  )  )  )
-   ( (  ( ) ⁏  )  )  (
-  ) ⁏  )  ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &    .
----
-
-          ▄▄▆▆██▆▆▄▄
-       ▄▆█▓▒░░░░░░▒▓█▆▄
-     ▄█▓▒░  ░▒▒▒▒░  ░▒▓█▄
-    ▐█▒░  ░▒▓████▓▒░  ░▒█▌
-    ▝█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█▘
-       )  ) )  ║║ ╱ ╱ )
-      (  ╱ ╱ ╱╱ ( )  )
-     ╱ ╱ ) ))  )  )  )
-   ( (  ( ) ⁏  )  )  (
-  ) ⁏  )  ⁏ @  )  ⁏ )
- ⁏  $  ⁏  ;   ⁏  * ⁏
- #     %     &   .
----