@anchrd/intel-ui 0.16.0 → 0.17.0

package/src/board/board-items/board-items.ts

@@ -0,0 +1,183 @@
+import type { BoardStatus, BoardTask } from "@anchrd/intel-contract";
+import { type BoardTone, labelOf, toneOf } from "@/board/board-status/board-status.ts";
+
+/**
+ * One task as a dated thing (anchrd/intel#286).
+ *
+ * ⚠️ This is THE adapter between a board and every view that arranges by date — the calendar and
+ * Gantt (anchrd/intel#293). The shape is deliberately the item model those views already speak
+ * (`id`, `name`, `startAt`, `endAt`, `status`), so the second view was a renderer over this list
+ * rather than a second reading of `BoardTask`. Two readings would disagree about the one thing that
+ * is genuinely subtle here — what a task without a start date spans — and they would disagree
+ * quietly, in a picture.
+ */
+export interface BoardItem {
+  id: string;
+  name: string;
+  // ⚠️ Both are LOCAL midnight, never UTC. A `BoardTaskDate` is a day and carries no zone by
+  // contract, so `new Date("2026-08-07")` — which JavaScript reads as UTC midnight — would show the
+  // 6th to every reader west of Greenwich. A task due on a day is due on that day for everybody.
+  startAt: Date;
+  endAt: Date;
+  status: { id: string; label: string; tone: BoardTone };
+  // Something it waits for is still open. Carried on the item rather than looked up again by each
+  // view: it is the same question in the calendar, the graph and the card.
+  blocked: boolean;
+  task: BoardTask;
+}
+
+export interface BoardSchedule {
+  items: BoardItem[];
+  /**
+   * The tasks that have no place in a date grid.
+   *
+   * ⚠️ Handed back rather than dropped. A calendar that silently omits everything without a due
+   * date is a calendar that lies about how much work there is — so the view says how many are
+   * missing and where they are instead (the DoD calls this out by name).
+   */
+  undated: BoardTask[];
+}
+
+// A day as the reader's own midnight. Split rather than handed to `new Date(string)` for the reason
+// in `BoardItem.startAt`.
+export function localDay(date: string): Date | null {
+  const parts = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+  if (!parts) return null;
+  const [year, month, day] = [Number(parts[1]), Number(parts[2]), Number(parts[3])];
+  const parsed = new Date(year, month - 1, day);
+  // A `BoardTaskDate` is validated on both sides, so this only catches a real impossibility such as
+  // the 31st of February — which `Date` would roll forward into March rather than refuse.
+  return parsed.getFullYear() === year &&
+    parsed.getMonth() === month - 1 &&
+    parsed.getDate() === day
+    ? parsed
+    : null;
+}
+
+export function sameDay(left: Date, right: Date): boolean {
+  return (
+    left.getFullYear() === right.getFullYear() &&
+    left.getMonth() === right.getMonth() &&
+    left.getDate() === right.getDate()
+  );
+}
+
+/**
+ * A day back as the `BoardTaskDate` it is written as — the exact inverse of `localDay`
+ * (anchrd/intel#293).
+ *
+ * ⚠️ Built from the LOCAL components, never from `toISOString()`. That is the same trap as reading a
+ * date, in the other direction and with worse consequences: `new Date(2026, 7, 7).toISOString()` is
+ * `2026-08-06T22:00:00Z` in Berlin, so a bar dragged onto the 7th would be SAVED as the 6th. Reading
+ * it wrong draws the wrong day; writing it wrong stores the wrong day, and every surface then agrees
+ * about a date nobody chose.
+ *
+ * It exists because Gantt writes dates back and the calendar only reads them. One pair of functions
+ * in one place, so the two directions cannot disagree about what a day is.
+ */
+export function dayValue(day: Date): string {
+  const month = String(day.getMonth() + 1).padStart(2, "0");
+  const date = String(day.getDate()).padStart(2, "0");
+  return `${day.getFullYear()}-${month}-${date}`;
+}
+
+/**
+ * The same day, a whole number of days later or earlier.
+ *
+ * ⚠️ Calendar arithmetic, not milliseconds. `time + 86_400_000` is 23 or 25 hours across a DST
+ * boundary, which lands the result on the previous day at 23:00 or the next at 01:00 — and a board
+ * whose dates shift by one on the last Sunday in March is a board nobody would trust again. `Date`
+ * normalises an out-of-range day (the 32nd of August is the 1st of September), so this needs no
+ * month handling of its own.
+ */
+export function addDays(day: Date, count: number): Date {
+  return new Date(day.getFullYear(), day.getMonth(), day.getDate() + count);
+}
+
+/**
+ * How many days lie between two days, as a whole number.
+ *
+ * ⚠️ Compared as UTC noon-free day numbers rather than by subtracting local times, for the DST
+ * reason above: the difference between two local midnights is not always a multiple of 24 hours, and
+ * a `Math.round` over that is right until the one week of the year it is not.
+ */
+export function daysBetween(from: Date, to: Date): number {
+  const left = Date.UTC(from.getFullYear(), from.getMonth(), from.getDate());
+  const right = Date.UTC(to.getFullYear(), to.getMonth(), to.getDate());
+  return Math.round((right - left) / 86_400_000);
+}
+
+/**
+ * Which task each task hangs under, once the list has been cut down.
+ *
+ * ⚠️ A task whose parent is not in the list becomes a ROOT rather than disappearing, and that is the
+ * whole reason this exists. Hiding the shelf hides archived tasks; an archived epic with two live
+ * tasks under it must not take them off the screen with it. The hierarchy is a fact about the board,
+ * what is shown is a question the reader asked, and the second must not silently answer the first.
+ *
+ * ⚠️ A chain that comes back to where it started is broken here, at the task that closes it. The
+ * write path refuses a cycle (#285), so this cannot be reached from a board Intel wrote — but the
+ * cost of being wrong about that is not a wrong picture, it is a walk that recurses until the tab
+ * dies. Depth is capped at five, so the walk is bounded anyway.
+ *
+ * ⚠️ It lives HERE, beside the dated reading, because the table and Gantt both need it
+ * (anchrd/intel#293). Two copies of a rule with two subtleties in it are two copies that drift, and
+ * the drift would show up as a task that is a root in one view and a child in the other.
+ */
+export function rootedParents(tasks: BoardTask[]): Map<string, string | null> {
+  const byId = new Map(tasks.map((task) => [task.id, task]));
+  const parents = new Map<string, string | null>();
+  for (const task of tasks) {
+    const direct = task.parentId !== null && byId.has(task.parentId) ? task.parentId : null;
+    let cursor = direct;
+    const seen = new Set([task.id]);
+    while (cursor !== null && !seen.has(cursor)) {
+      seen.add(cursor);
+      const next = byId.get(cursor)?.parentId ?? null;
+      cursor = next !== null && byId.has(next) ? next : null;
+    }
+    parents.set(task.id, cursor === null ? direct : null);
+  }
+  return parents;
+}
+
+/**
+ * The board as a list of dated items, and the tasks that are not one.
+ *
+ * ⚠️ `dueDate` is what makes a task an item — a start date alone does not. A bar has to end
+ * somewhere, and a task that has only begun would either be drawn to today (a date nobody entered)
+ * or to forever. `startDate` therefore only ever shortens or lengthens the span; without one, the
+ * item is the single day it is due on.
+ */
+export function boardSchedule(
+  tasks: BoardTask[],
+  statuses: BoardStatus[],
+  blockedBy: (task: BoardTask) => BoardTask[],
+): BoardSchedule {
+  const items: BoardItem[] = [];
+  const undated: BoardTask[] = [];
+  for (const task of tasks) {
+    const end = task.dueDate === null ? null : localDay(task.dueDate);
+    if (end === null) {
+      undated.push(task);
+      continue;
+    }
+    const start = task.startDate === null ? null : localDay(task.startDate);
+    items.push({
+      id: task.id,
+      name: task.title,
+      // A start after the due date is a board somebody typed wrong, not a bar drawn backwards. The
+      // due date wins because it is the one the calendar files the task under.
+      startAt: start !== null && start <= end ? start : end,
+      endAt: end,
+      status: {
+        id: task.status,
+        label: labelOf(task.status, statuses),
+        tone: toneOf(task.status, statuses),
+      },
+      blocked: blockedBy(task).length > 0,
+      task,
+    });
+  }
+  return { items, undated };
+}

package/src/board/board-kanban/board-kanban.ts

@@ -0,0 +1,97 @@
+import type { BoardTask } from "@anchrd/intel-contract";
+import type { MoveTask } from "@/board/board-data/board-data.types.ts";
+import type { KanbanDrop } from "@/components/ui/kanban.tsx";
+
+/**
+ * What a drop means, as the one `board_task_move` it is worth.
+ *
+ * ⚠️ Neighbours, never an index. The server mints the fractional key between the two tasks named
+ * here (#285), so one drag writes one task and renumbers nothing — the reason a board is addressed
+ * by task id and not by position at all. A UI that sent a position would have to send the whole
+ * column with it to be unambiguous.
+ *
+ * ⚠️ `null` for a drag that changed nothing, and that is half the point of this function. dnd-kit
+ * reports a drop wherever the pointer was let go, including back on the card's own place; sending
+ * a move for that would write a version, bump the board and show up in the audit as work that did
+ * not happen.
+ *
+ * `lanes` is what the board DRAWS — root tasks per column, in order. Subtasks are not lane cards
+ * (they are a counter on their parent), so they are not in it and cannot be dropped on either.
+ */
+export function moveFromDrop(
+  drop: KanbanDrop,
+  lanes: Map<string, BoardTask[]>,
+  byId: Map<string, BoardTask>,
+  // The statuses the board actually lists. ⚠️ Not the same as the lanes: a lane is also drawn for a
+  // status the board no longer has, so that the cards left in it stay visible — and that lane must
+  // not be somewhere a card can be MOVED. The server refuses a task in a status the board does not
+  // have, so a drop there would be a refusal, an invalidation and no word to the reader.
+  writable: ReadonlySet<string>,
+): MoveTask | null {
+  const active = byId.get(drop.activeId);
+  // ⚠️ Let go over itself is the commonest drag of all — a click that travelled five pixels — and
+  // it has to be nothing before any of the arithmetic below runs. Read as "dropped on a card", it
+  // would compute a landing place for a card that never left, which is the shape of a write that
+  // says work happened.
+  if (drop.overId === null || drop.overId === drop.activeId || active === undefined) return null;
+
+  // The drop landed either on a column's empty space — then its id is the status — or on a card,
+  // and then the column is that card's. A card the board does not draw (a subtask, or one filtered
+  // away) resolves to neither and the drag is a no-op rather than a guess.
+  const overTask = byId.get(drop.overId);
+  const status = overTask?.status ?? (lanes.has(drop.overId) ? drop.overId : null);
+  if (status === null || !writable.has(status)) return null;
+
+  const lane = lanes.get(status) ?? [];
+  const from = lane.findIndex((task) => task.id === active.id);
+  const rest = lane.filter((task) => task.id !== active.id);
+
+  let landing: number;
+  if (overTask === undefined) {
+    // Let go over the column rather than over a card: the end of it.
+    landing = rest.length;
+  } else {
+    const overIndex = rest.findIndex((task) => task.id === overTask.id);
+    if (overIndex === -1) return null;
+    // Dragged downwards inside its own column, the card takes the place BELOW the one it was let go
+    // over — the same reading `arrayMove` has, and the one the pointer suggests. Every other case
+    // puts it above.
+    const overInLane = lane.findIndex((task) => task.id === overTask.id);
+    landing = from !== -1 && from < overInLane ? overIndex + 1 : overIndex;
+  }
+
+  // Re-inserting where it came from is the arrangement it already had.
+  if (from !== -1 && landing === from) return null;
+
+  return {
+    taskId: active.id,
+    status,
+    afterTaskId: rest[landing - 1]?.id ?? null,
+    beforeTaskId: rest[landing]?.id ?? null,
+  };
+}
+
+/**
+ * How much of a task's subtree is finished — the counter a card carries instead of its children.
+ *
+ * ⚠️ The whole subtree, not the direct children. A card that says "1/2" while three of the four
+ * things under it are open would be worse than no counter: the number would be true of a level
+ * nobody is looking at.
+ */
+export function subtaskCount(
+  taskId: string,
+  childrenOf: Map<string, BoardTask[]>,
+  settled: (task: BoardTask) => boolean,
+): { done: number; total: number } {
+  let done = 0;
+  let total = 0;
+  const walk = (id: string) => {
+    for (const child of childrenOf.get(id) ?? []) {
+      total += 1;
+      if (settled(child)) done += 1;
+      walk(child.id);
+    }
+  };
+  walk(taskId);
+  return { done, total };
+}

package/src/board/board-kanban/board-kanban.tsx

@@ -0,0 +1,211 @@
+import { ArchivedBoardStatusId, type BoardTask } from "@anchrd/intel-contract";
+import { useMemo } from "react";
+import { BoardCardBody } from "@/board/board-card/board-card.tsx";
+import { visibleStatuses } from "@/board/board-data/board-data.ts";
+import { labelOf, toneOf } from "@/board/board-status/board-status.ts";
+import type { BoardViewProps } from "@/board/board-views/board-views.types.ts";
+import {
+  KanbanBoard,
+  KanbanCard,
+  KanbanCards,
+  KanbanHeader,
+  KanbanProvider,
+} from "@/components/ui/kanban.tsx";
+import { useI18n } from "@/i18n/i18n-context.tsx";
+import { moveFromDrop, subtaskCount } from "./board-kanban.ts";
+
+/**
+ * The board as lanes (anchrd/intel#286).
+ *
+ * ⚠️ Lanes are the board's `statuses` in their own order — not a list this view keeps. Renaming a
+ * column in `board_configure` renames the lane, and the id under it never moves, so no task has to
+ * be rewritten to follow.
+ *
+ * ⚠️ Only root tasks are cards. A subtask is a counter on its parent (`subtaskCount`); drawing it
+ * as a lane card as well would put one piece of work on the board twice, once inside its parent and
+ * once beside it. The whole hierarchy is the table's job and the detail panel's.
+ */
+export function BoardKanban({ board, select, showArchived }: BoardViewProps) {
+  const i18n = useI18n();
+
+  const columns = useMemo(() => {
+    // ⚠️ `archived` is not a lane by default and is not a stage either — it is the shelf a task
+    // is swept onto, and a board that shows it always spends a fifth of its width on work
+    // somebody has finished with. The switch that brings it back is in the bar above.
+    /**
+     * ⚠️ One lane per status id, however often the list names it (anchrd/intel#321).
+     *
+     * Two lanes under one id is the half of that ticket that does not throw, which is what makes it
+     * the worse half: `lanes.get(column.id)` answers both of them with the same cards, so the same
+     * work stands in two columns, `useDroppable` registers one id twice and a drop has two targets
+     * that are one — a screen that looks like it is working. The bundle import refuses such a
+     * document now; a board imported before it is still stored as it was written, and the first
+     * mention is the lane to keep because it is the one `labelOf` and `toneOf` already answer with
+     * — a lane drawn under the second label would have carried the first one's colour.
+     */
+    const seen = new Set<string>();
+    const listed = (showArchived ? board.statuses : visibleStatuses(board.statuses))
+      .filter((status) => {
+        if (seen.has(status.id)) return false;
+        seen.add(status.id);
+        return true;
+      })
+      .map((status) => ({ id: status.id, name: status.label }));
+    /**
+     * ⚠️ And a lane at the end for every status a task still stands in that the board no longer
+     * lists.
+     *
+     * Configuring a column away does not rewrite the tasks that were in it (#285), so this is
+     * reachable — through `board_configure` over MCP, which has no dialog stopping it. Without the
+     * extra lane those cards would be in `board.tasks`, counted in the title line, and drawn
+     * nowhere: gone from the one view a board is opened for, with nothing saying so. The other
+     * others already keep them (`orderedTasks` sorts them last, `labelOf` falls back to the raw
+     * id), and no two views may disagree about what is on the board.
+     */
+    const known = new Set(listed.map((column) => column.id));
+    const stray = new Set(
+      board.tasks
+        .filter((task) => task.parentId === null && !known.has(task.status))
+        .filter((task) => showArchived || task.status !== ArchivedBoardStatusId)
+        .map((task) => task.status),
+    );
+    return [
+      ...listed.map((column) => ({ ...column, writable: true })),
+      // ⚠️ Drawn, never written into. The server refuses a task in a status the board does not have,
+      // so a card dropped here would be a refusal, an invalidation and nothing said to the reader.
+      // The lane is a place work is VISIBLE, not a place it can be put.
+      ...[...stray].map((id) => ({ id, name: labelOf(id, board.statuses), writable: false })),
+    ];
+  }, [board.statuses, board.tasks, showArchived]);
+
+  const writable = useMemo(
+    () => new Set(columns.filter((column) => column.writable).map((column) => column.id)),
+    [columns],
+  );
+
+  const lanes = useMemo(() => {
+    const byStatus = new Map<string, BoardTask[]>();
+    for (const column of columns) byStatus.set(column.id, []);
+    for (const task of board.tasks) {
+      if (task.parentId !== null) continue;
+      byStatus.get(task.status)?.push(task);
+    }
+    return byStatus;
+  }, [board.tasks, columns]);
+
+  const itemsByColumn = useMemo(
+    () => new Map([...lanes].map(([status, tasks]) => [status, tasks.map((task) => task.id)])),
+    [lanes],
+  );
+
+  const card = (task: BoardTask) => (
+    <BoardCardBody
+      task={task}
+      statusLabel={labelOf(task.status, board.statuses)}
+      toneDot={toneOf(task.status, board.statuses).dot}
+      blocked={board.blockedBy(task).length > 0}
+      subtasks={subtaskCount(task.id, board.childrenOf, board.settled)}
+    />
+  );
+
+  return (
+    <div className="min-h-0 flex-1 overflow-x-auto p-6">
+      <KanbanProvider
+        columns={columns}
+        itemsByColumn={itemsByColumn}
+        className="min-w-max"
+        announcements={{
+          onDragStart: ({ active }) =>
+            i18n.t("board.dnd.start", { task: board.byId.get(String(active.id))?.title ?? "" }),
+          onDragOver: ({ active, over }) =>
+            i18n.t("board.dnd.over", {
+              task: board.byId.get(String(active.id))?.title ?? "",
+              lane: over === null ? "" : laneName(String(over.id), board, columns),
+            }),
+          onDragEnd: ({ active, over }) =>
+            i18n.t("board.dnd.end", {
+              task: board.byId.get(String(active.id))?.title ?? "",
+              lane: over === null ? "" : laneName(String(over.id), board, columns),
+            }),
+          onDragCancel: ({ active }) =>
+            i18n.t("board.dnd.cancel", { task: board.byId.get(String(active.id))?.title ?? "" }),
+        }}
+        overlay={(activeId) => {
+          const task = board.byId.get(activeId);
+          return task ? (
+            <div className="w-72 rounded-lg border bg-card p-3 shadow-lg ring-2 ring-ring">
+              {card(task)}
+            </div>
+          ) : null;
+        }}
+        // ⚠️ Exactly one write per drag, and only when the card actually went somewhere.
+        // `moveFromDrop` answers `null` for a drop back onto its own place, and the mutation names
+        // the NEIGHBOURS rather than an index — the server mints the order key between them, so one
+        // drag writes one task and the other cards are not touched (#285).
+        onDrop={(drop) => {
+          const move = moveFromDrop(drop, lanes, board.byId, writable);
+          if (move) board.move.mutate(move);
+        }}
+      >
+        {(column) => (
+          <KanbanBoard
+            id={column.id}
+            // ⚠️ Read back off the list rather than off the argument: `KanbanProvider` hands its
+            // children a `KanbanColumn`, which is an id and a name — the primitive has no business
+            // knowing which of a board's columns may be written to.
+            droppable={columns.find((entry) => entry.id === column.id)?.writable !== false}
+            className="w-72 shrink-0"
+          >
+            <KanbanHeader>
+              <span
+                aria-hidden="true"
+                className={`size-2 rounded-full ${toneOf(column.id, board.statuses).dot}`}
+              />
+              <span className="min-w-0 truncate">{column.name}</span>
+              <span className="ml-auto text-xs font-normal text-muted-foreground tabular-nums">
+                {lanes.get(column.id)?.length ?? 0}
+              </span>
+            </KanbanHeader>
+            <KanbanCards id={column.id}>
+              {(lanes.get(column.id) ?? []).map((task) => (
+                <KanbanCard
+                  key={task.id}
+                  id={task.id}
+                  dragLabel={i18n.t("board.dragCard", { task: task.title })}
+                >
+                  {/* Two controls, each with a name of its own: the handle beside this one drags,
+                      this one opens. The pointer sensor's four-pixel threshold is what keeps a
+                      click on it from counting as a drag of nothing. */}
+                  <button
+                    type="button"
+                    className="w-full rounded text-left outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                    onClick={() => select(task.id)}
+                  >
+                    {card(task)}
+                  </button>
+                </KanbanCard>
+              ))}
+              {(lanes.get(column.id) ?? []).length === 0 ? (
+                <p className="px-1 py-2 text-xs text-muted-foreground">
+                  {column.id === ArchivedBoardStatusId
+                    ? i18n.t("board.archivedEmpty")
+                    : i18n.t("board.laneEmpty")}
+                </p>
+              ) : null}
+            </KanbanCards>
+          </KanbanBoard>
+        )}
+      </KanbanProvider>
+    </div>
+  );
+}
+
+function laneName(
+  overId: string,
+  board: BoardViewProps["board"],
+  columns: { id: string; name: string }[],
+): string {
+  const task = board.byId.get(overId);
+  const statusId = task?.status ?? overId;
+  return columns.find((column) => column.id === statusId)?.name ?? statusId;
+}

package/src/board/board-status/board-status.ts

@@ -0,0 +1,59 @@
+import { ArchivedBoardStatusId, type BoardStatus } from "@anchrd/intel-contract";
+
+/**
+ * How a status looks, in the three places a colour has to be spelled differently.
+ *
+ * `token` is the CSS variable name rather than a value, because Sigma paints to a canvas and cannot
+ * read a class (`resolveGraphColor` turns it into sRGB there). `dot` and `chip` are Tailwind
+ * classes for everything that is drawn in the DOM.
+ */
+export interface BoardTone {
+  token: string;
+  dot: string;
+  chip: string;
+}
+
+// ⚠️ Written out rather than built from a template string. Tailwind reads the source to decide
+// which classes to emit, and a class assembled at runtime — `bg-board-status-${n}` — is a class it
+// never sees and therefore never generates. The board would then be uncoloured in the production
+// build and correct in dev, which is the worst shape a bug can have.
+const Ramp: readonly BoardTone[] = [
+  { token: "--board-status-1", dot: "bg-board-status-1", chip: "border-board-status-1" },
+  { token: "--board-status-2", dot: "bg-board-status-2", chip: "border-board-status-2" },
+  { token: "--board-status-3", dot: "bg-board-status-3", chip: "border-board-status-3" },
+  { token: "--board-status-4", dot: "bg-board-status-4", chip: "border-board-status-4" },
+  { token: "--board-status-5", dot: "bg-board-status-5", chip: "border-board-status-5" },
+  { token: "--board-status-6", dot: "bg-board-status-6", chip: "border-board-status-6" },
+];
+
+// The shelf, and everything the board no longer has a column for. Both are "not a stage", and both
+// have to read as background rather than as one more colour competing with the stages.
+const Shelved: BoardTone = {
+  token: "--muted-foreground",
+  dot: "bg-muted-foreground",
+  chip: "border-border",
+};
+
+/**
+ * The colour a status is drawn in.
+ *
+ * ⚠️ By POSITION in the board's own list, not by id. A status list is configured per board, so
+ * `done` is no more a colour than "the fourth column" is a name — and a board that renames a column
+ * must not have its whole ramp shift underneath it. Positions count the working columns only, so
+ * moving `archived` around in the list cannot recolour everything after it.
+ */
+export function toneOf(statusId: string, statuses: BoardStatus[]): BoardTone {
+  if (statusId === ArchivedBoardStatusId) return Shelved;
+  const position = statuses
+    .filter((status) => status.id !== ArchivedBoardStatusId)
+    .findIndex((status) => status.id === statusId);
+  if (position === -1) return Shelved;
+  return Ramp[position % Ramp.length] ?? Shelved;
+}
+
+// The label a reader sees. A task can hold a status the board no longer lists — configuring a
+// column away does not rewrite the tasks that stood in it — and the raw id is then the only honest
+// answer: it says which column is missing instead of pretending the task has none.
+export function labelOf(statusId: string, statuses: BoardStatus[]): string {
+  return statuses.find((status) => status.id === statusId)?.label ?? statusId;
+}

package/src/board/board-statuses/board-statuses.ts

@@ -0,0 +1,63 @@
+import { ArchivedBoardStatusId, type BoardStatus } from "@anchrd/intel-contract";
+
+// One row of the dialog. `terminal` travels with it because it is written in the same call as the
+// label and the order — `board_configure` takes the list whole (#285).
+export interface BoardStatusDraft {
+  id: string;
+  label: string;
+  terminal: boolean;
+}
+
+/**
+ * A status id out of the label somebody typed.
+ *
+ * ⚠️ The id is what every task in the column carries, so it is minted ONCE and never follows a
+ * rename — renaming changes the label and no task has to be rewritten (#285). This function is
+ * therefore only ever called for a NEW column.
+ *
+ * The shape is the contract's: lower case, digits and underscores, starting on an alphanumeric,
+ * forty characters at most. A label that leaves nothing usable — one written in a script that has
+ * no ASCII form — falls back to a generated id rather than being refused, because a column named
+ * in Japanese is a column somebody meant to make.
+ */
+export function statusIdFrom(label: string, taken: ReadonlySet<string>): string {
+  const base = label
+    .toLowerCase()
+    .normalize("NFKD")
+    // Combining marks removed, so "Prüfung" becomes "prufung" rather than losing the letter.
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .slice(0, 40)
+    .replace(/^[^a-z0-9]+/, "");
+  const seed = base === "" ? "status" : base;
+  if (!taken.has(seed) && seed !== ArchivedBoardStatusId) return seed;
+  for (let suffix = 2; ; suffix += 1) {
+    const candidate = `${seed.slice(0, 37)}_${suffix}`;
+    if (!taken.has(candidate) && candidate !== ArchivedBoardStatusId) return candidate;
+  }
+}
+
+/**
+ * The list as `board_configure` takes it: whole, in the order it should be drawn.
+ *
+ * ⚠️ `archived` is put back at the end if the editor lost it. The contract refuses a list without
+ * it, and a refusal here would be a dialog that cannot be saved for a reason the reader never
+ * caused — the shelf is not a column anybody is editing.
+ */
+export function configurableStatuses(statuses: BoardStatus[]): BoardStatusDraft[] {
+  const working = statuses.filter((status) => status.id !== ArchivedBoardStatusId);
+  const shelf = statuses.find((status) => status.id === ArchivedBoardStatusId);
+  return [
+    ...working.map((status) => ({
+      id: status.id,
+      label: status.label,
+      terminal: status.terminal,
+    })),
+    // ⚠️ Always `true` for the shelf, whatever a stored board says. The contract refuses an explicit
+    // `false` for it (anchrd/intel#311), so sending anything else would be a dialog that cannot be
+    // saved — and a shelf that did not mean finished would hold every archived task open as a
+    // blocker forever.
+    { id: ArchivedBoardStatusId, label: shelf?.label ?? "Archived", terminal: true },
+  ];
+}