@sigrun/tui 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-10-24
+### Added
+- Extension surfaces and live surface updates.
+- Typed block rendering: content, braille charts, collections, forms,
+  page shells, images, navigation, and all three keymaps.
+
 ## [0.1.0] - 2026-10-21
 ### Added
 - First published release of the TUI (workspace package of

package/dist/actions.d.ts

@@ -9,8 +9,13 @@
  * keymap decides WHICH action a key means per focus; the app decides
  * what the action DOES per focus.
  */
-/** The three focusable regions. */
-export type Focus = "composer" | "list" | "transcript";
+/** The three focusable regions. `surface` (Task 4, UI-blocks U2) is a
+ *  block surface pane (lanes/calendar/collection) — the blocks.* keys
+ *  route ONLY while it has focus. While a surface is focused the
+ *  transcript/list nav keys (y/f/e//?) are inert (the keymaps pass
+ *  them); Task 6's surface host decides any surface-side meaning for
+ *  them. */
+export type Focus = "composer" | "list" | "transcript" | "surface";
 /** Every dispatchable intent. */
 export type Action = {
     readonly type: "focus";
@@ -71,6 +76,42 @@ export type Action = {
 } | {
     readonly type: "run-command";
     readonly line: string;
+}
+/** Pick up the item under the cursor (m / M-m). */
+ | {
+    readonly type: "blocks.pickUp";
+}
+/** Drop the picked-up item at its placement (Enter). */
+ | {
+    readonly type: "blocks.drop";
+}
+/** Cancel the pick-up (Esc). */
+ | {
+    readonly type: "blocks.cancelMove";
+}
+/** Toggle the selection of the item under the cursor (Space). */
+ | {
+    readonly type: "blocks.select";
+}
+/** Open the action menu (`.` — bulk actions, "Move to…"). */
+ | {
+    readonly type: "blocks.actionMenu";
+}
+/** Toggle the checkable field of the item under the cursor (x). */
+ | {
+    readonly type: "blocks.check";
+}
+/** Previous calendar range ([). */
+ | {
+    readonly type: "blocks.rangePrev";
+}
+/** Next calendar range (]). */
+ | {
+    readonly type: "blocks.rangeNext";
+}
+/** Return the calendar range to today (t). */
+ | {
+    readonly type: "blocks.today";
 };
 /** The dispatch surface {@link TuiApp} implements. */
 export interface ActionHost {

package/dist/api.d.ts

@@ -25,6 +25,7 @@ export type { AbortResponse, AmbientList, AmbientWire, CompactResponse, Configur
 export type { CommandRunResponse, CommandsResponse, SlashCommand } from "@sigrun/shared/commands";
 export type { JobSpec, JobSchedule, JobAction, JobWire, JobRunWire, JobRevisionWire, } from "@sigrun/shared/jobs";
 export type { JobsResponse, JobRunResponse } from "@sigrun/shared/views";
+export type { ExtensionsResponse, ExtensionInfo, ExtensionSurfaceInfo } from "@sigrun/shared/views";
 export type { SessionMeta, SessionMetaPatch } from "@sigrun/shared/session-meta";
 /** One answer to a pending interaction (the ONE generic route's body). */
 export interface InteractionAnswerInput {
@@ -80,6 +81,7 @@ export interface SigrunClientOptions {
     readonly fetch?: FetchLike;
 }
 /** The typed §5 client. See {@link SigrunClientOptions} for the seams. */
+import type { ExtensionsResponse } from "@sigrun/shared/views";
 export declare class SigrunClient {
     #private;
     constructor(options: SigrunClientOptions);
@@ -117,6 +119,9 @@ export declare class SigrunClient {
     getAmbient(id: number): Promise<AmbientList>;
     /** `GET /v1/commands` — the slash-command catalog (a boot constant). */
     getCommands(): Promise<CommandsResponse>;
+    /** `GET /v1/extensions` — the loaded-extension inventory (U3 Task 5:
+     *  the sidebar's Views group + panels read the declared surfaces). */
+    listExtensions(): Promise<ExtensionsResponse>;
     /**
      * `POST /v1/conversations/:id/commands/:name` — invoke an extension
      * slash command (W5 Task 3): the server runs the winning declaration

package/dist/api.js

@@ -27,7 +27,6 @@ export class SigrunApiError extends Error {
         this.body = body;
     }
 }
-/** The typed §5 client. See {@link SigrunClientOptions} for the seams. */
 export class SigrunClient {
     #baseUrl;
     #fetch;
@@ -139,6 +138,11 @@ export class SigrunClient {
     getCommands() {
         return this.#get("/v1/commands");
     }
+    /** `GET /v1/extensions` — the loaded-extension inventory (U3 Task 5:
+     *  the sidebar's Views group + panels read the declared surfaces). */
+    listExtensions() {
+        return this.#get("/v1/extensions");
+    }
     /**
      * `POST /v1/conversations/:id/commands/:name` — invoke an extension
      * slash command (W5 Task 3): the server runs the winning declaration

package/dist/blocks/braille.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The Braille dot canvas and the display ramps (UI-blocks spec §5.4):
+ * the pieces `chart` and the narrow-fallback sparkline draw with.
+ *
+ * - {@link BrailleCanvas} is a `cells×rows` cell grid of 2×4 dot
+ *   subpixels (Unicode Braille Patterns, U+2800 base). Each cell also
+ *   records the index of the series that plotted into it LAST, which
+ *   is how multi-colour charts colour a shared cell.
+ * - {@link sparkline} renders a value series onto the eighth-block
+ *   ramp `▁▂▃▄▅▆▇█` (or the ASCII ramp `_.,-+=*#` on a no-Unicode
+ *   terminal), downsampling with the shared `lttb` when the series is
+ *   longer than the cell budget.
+ */
+/** A Braille dot canvas: `cells` columns × `rows` rows of 2×4 dots. */
+export declare class BrailleCanvas {
+    #private;
+    constructor(cells: number, rows: number);
+    /** Plot one dot; out-of-range coordinates are ignored. */
+    plot(x: number, y: number, series?: number): void;
+    /** A straight dot-space line from (x0, y0) to (x1, y1): the steps
+     * are the CHEBYSHEV distance (diagonal-adjacent dots step one
+     * dot-space cell at a time). */
+    line(x0: number, y0: number, x1: number, y1: number, series?: number): void;
+    /** Fill the dot rectangle (x0..x1, y0..y1) inclusive. */
+    fill(x0: number, y0: number, x1: number, y1: number, series?: number): void;
+    /** The dot bits set in one cell. */
+    cellBits(cellX: number, cellY: number): number;
+    /** The series index that plotted into this cell last (−1: none). */
+    cellOwner(cellX: number, cellY: number): number;
+    /** Clear one cell row (a threshold rule paints over it). */
+    blankRow(cellY: number): void;
+    /** The canvas as one Braille string per cell row. */
+    rows(): string[];
+}
+/**
+ * A one-cell-per-sample sparkline of `values`, at most `maxCells`
+ * cells (longer series downsample with `lttb`, keeping both ends).
+ * `unicode: false` selects the ASCII ramp. Empty input renders empty;
+ * a flat series renders mid-height cells.
+ */
+export declare function sparkline(values: readonly number[], maxCells: number, unicode: boolean): string;

package/dist/blocks/braille.js

@@ -0,0 +1,131 @@
+/**
+ * The Braille dot canvas and the display ramps (UI-blocks spec §5.4):
+ * the pieces `chart` and the narrow-fallback sparkline draw with.
+ *
+ * - {@link BrailleCanvas} is a `cells×rows` cell grid of 2×4 dot
+ *   subpixels (Unicode Braille Patterns, U+2800 base). Each cell also
+ *   records the index of the series that plotted into it LAST, which
+ *   is how multi-colour charts colour a shared cell.
+ * - {@link sparkline} renders a value series onto the eighth-block
+ *   ramp `▁▂▃▄▅▆▇█` (or the ASCII ramp `_.,-+=*#` on a no-Unicode
+ *   terminal), downsampling with the shared `lttb` when the series is
+ *   longer than the cell budget.
+ */
+import { lttb } from "@sigrun/shared/blocks";
+/**
+ * Dot bit per (x, y) subpixel: the Unicode standard layout — the
+ * left column holds dots 1,2,3,7 and the right column dots 4,5,6,8,
+ * TOP-DOWN. Dot space is TOP-DOWN too: (x, 0) is the TOP row of the
+ * canvas (plot(0,0) = dot 1 = 0x01). The suite pins plot(0,0)=0x01,
+ * plot(0,2)=0x04, plot(1,1)=0x10, plot(1,3)=0x80 on a one-row
+ * canvas; chart inverts its y axis before plotting.
+ */
+const DOT_BIT = [
+    [0x01, 0x02, 0x04, 0x40],
+    [0x08, 0x10, 0x20, 0x80],
+];
+/** A Braille dot canvas: `cells` columns × `rows` rows of 2×4 dots. */
+export class BrailleCanvas {
+    #cells;
+    #rows;
+    #bits;
+    #owner;
+    constructor(cells, rows) {
+        this.#cells = Math.max(0, cells);
+        this.#rows = Math.max(0, rows);
+        this.#bits = new Uint8Array(this.#cells * this.#rows);
+        this.#owner = new Int32Array(this.#cells * this.#rows).fill(-1);
+    }
+    /** Plot one dot; out-of-range coordinates are ignored. */
+    plot(x, y, series) {
+        const cellX = Math.floor(x / 2);
+        const cellY = Math.floor(y / 4);
+        if (cellX < 0 || cellY < 0 || cellX >= this.#cells || cellY >= this.#rows)
+            return;
+        const index = cellY * this.#cells + cellX;
+        const row = y % 4;
+        const col = x % 2;
+        const bit = DOT_BIT[col][row] ?? 0;
+        this.#bits[index] = (this.#bits[index] ?? 0) | bit;
+        if (series !== undefined)
+            this.#owner[index] = series;
+    }
+    /** A straight dot-space line from (x0, y0) to (x1, y1): the steps
+     * are the CHEBYSHEV distance (diagonal-adjacent dots step one
+     * dot-space cell at a time). */
+    line(x0, y0, x1, y1, series) {
+        const steps = Math.max(Math.abs(x1 - x0), Math.abs(y1 - y0), 1);
+        for (let i = 0; i <= steps; i++) {
+            this.plot(Math.round(x0 + ((x1 - x0) * i) / steps), Math.round(y0 + ((y1 - y0) * i) / steps), series);
+        }
+    }
+    /** Fill the dot rectangle (x0..x1, y0..y1) inclusive. */
+    fill(x0, y0, x1, y1, series) {
+        for (let y = Math.min(y0, y1); y <= Math.max(y0, y1); y++) {
+            for (let x = Math.min(x0, x1); x <= Math.max(x0, x1); x++) {
+                this.plot(x, y, series);
+            }
+        }
+    }
+    /** The dot bits set in one cell. */
+    cellBits(cellX, cellY) {
+        return this.#bits[cellY * this.#cells + cellX] ?? 0;
+    }
+    /** The series index that plotted into this cell last (−1: none). */
+    cellOwner(cellX, cellY) {
+        return this.#owner[cellY * this.#cells + cellX] ?? -1;
+    }
+    /** Clear one cell row (a threshold rule paints over it). */
+    blankRow(cellY) {
+        if (cellY < 0 || cellY >= this.#rows)
+            return;
+        for (let cell = 0; cell < this.#cells; cell++) {
+            const index = cellY * this.#cells + cell;
+            this.#bits[index] = 0;
+            this.#owner[index] = -1;
+        }
+    }
+    /** The canvas as one Braille string per cell row. */
+    rows() {
+        const out = [];
+        for (let row = 0; row < this.#rows; row++) {
+            let line = "";
+            for (let cell = 0; cell < this.#cells; cell++) {
+                line += String.fromCharCode(0x2800 + this.cellBits(cell, row));
+            }
+            out.push(line);
+        }
+        return out;
+    }
+}
+/** The eighth-block ramp (index 0..8: empty through full). */
+const BLOCK_RAMP = "▁▂▃▄▅▆▇█"; // 8 cells, index 0..7
+/** The ASCII ramp for no-Unicode terminals (same 8 shape heights). */
+const ASCII_RAMP = "_.,-+=*#";
+/**
+ * A one-cell-per-sample sparkline of `values`, at most `maxCells`
+ * cells (longer series downsample with `lttb`, keeping both ends).
+ * `unicode: false` selects the ASCII ramp. Empty input renders empty;
+ * a flat series renders mid-height cells.
+ */
+export function sparkline(values, maxCells, unicode) {
+    if (values.length === 0 || maxCells <= 0)
+        return "";
+    const points = values.map((value, index) => [index, value]);
+    const sampled = lttb(points, Math.max(1, maxCells));
+    const ys = sampled.map((point) => point[1]);
+    const min = Math.min(...ys);
+    const max = Math.max(...ys);
+    const ramp = unicode ? BLOCK_RAMP : ASCII_RAMP;
+    // One shape per cell: floor(t * 8) clamped to the ramp (the top
+    // eighth of the range is the full block). A flat series renders
+    // mid-height (index 3 of 8).
+    return sampled
+        .map((point) => {
+        if (max === min)
+            return ramp[3];
+        const t = (point[1] - min) / (max - min);
+        return ramp[Math.max(0, Math.min(7, Math.floor(t * 8)))];
+    })
+        .join("");
+}

package/dist/blocks/chart.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The `chart` block (UI-blocks spec §5.4): one y-axis, mixed series
+ * kinds, thresholds as horizontal rules.
+ *
+ * - Lines and areas draw on a {@link BrailleCanvas} (2×4 dots per
+ *   cell); bars draw with the block ramp `▁▂▃▄▅▆▇█` on one row per
+ *   tick; stacked `area`/`bar` series accumulate.
+ * - A threshold draws as a dashed rule (`╌`, ASCII `-`) in its tone.
+ * - Below 30 cells the chart degrades to a sparkline plus the latest
+ *   value per series (§12.3); below 80 the legend moves below the
+ *   plot.
+ * - Long series downsample with the shared `lttb` before plotting.
+ */
+import type { Component } from "@earendil-works/pi-tui";
+import type { ChartBlock, ChartSeries } from "@sigrun/shared/blocks";
+import { type BlockCtx } from "./context.js";
+/** `chart`: the spec §5.4 block. */
+export declare function renderChart(block: ChartBlock, ctx: BlockCtx): Component;
+/** Re-exported so the render dispatch imports one module per block. */
+export type { ChartSeries };