@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/widgets/composite/recipe.d.ts

@@ -0,0 +1,148 @@
+import type { AisleKind, MealKind } from '../data-kit/icons.js';
+import type { Status } from '../data-kit/types.js';
+export type Slot = MealKind;
+export type Aisle = AisleKind;
+export interface Ingredient {
+    id?: string;
+    name: string;
+    qty?: number;
+    unit?: string;
+    note?: string;
+    aisle?: Aisle;
+}
+export interface RecipeStep {
+    id?: string;
+    text: string;
+    minutes?: number;
+    tip?: string;
+}
+export interface RecipeData {
+    id: string;
+    name: string;
+    kind?: Slot;
+    image?: string;
+    minutes?: number;
+    serves: number;
+    /** Per serving. */
+    kcal?: number;
+    /** Per serving. */
+    protein_g?: number;
+    tags?: string[];
+    ingredients: Ingredient[];
+    steps?: RecipeStep[];
+}
+export interface PlanMeal {
+    id?: string;
+    slot: Slot;
+    /** A recipe id (or name) from `recipes`. */
+    recipe: string;
+}
+export interface PlanDay {
+    id?: string;
+    /** "Mon", "Monday 12 Oct": shown as written. `label` is read too. */
+    day: string;
+    meals: PlanMeal[];
+}
+/** Per person per day. */
+export interface Goal {
+    kcal?: number;
+    protein_g?: number;
+}
+export declare const SLOTS: readonly Slot[];
+export declare const AISLES: readonly Aisle[];
+export declare function rec(v: unknown): Record<string, unknown>;
+export declare function list(v: unknown): unknown[];
+export declare const toAisle: (v: unknown) => Aisle;
+/** "breakfast" → "Breakfast"; an unknown slot shows as written. */
+export declare const slotLabel: (slot: string) => string;
+/** A positive count, else undefined. */
+export declare function positive(v: unknown): number | undefined;
+/** A nutrition value: a number, "550" or "22g" / "550 kcal"; negative or junk is missing. */
+export declare function nutrient(v: unknown): number | undefined;
+/** A recipe ref as words: "leftover-pizza" reads "Leftover pizza". */
+export declare const humanRef: (ref: string) => string;
+/** How much to multiply the written quantities by; 1 when `serves` is unusable. */
+export declare function scaleFactor(want: unknown, serves: unknown): number;
+/**
+ * A quantity as a cook writes it: 1.5 cups → "1½", 0.333 tsp → "⅓",
+ * 562.5 g → "563", 1.25 kg → "1.25". Missing or non-finite → ''.
+ */
+export declare function formatQty(qty: unknown, unit?: unknown): string;
+/** The unit a sum is kept under: lowercased, a counted unit in its singular. */
+export declare function baseUnit(unit: unknown): string;
+/** The unit as written, made singular or plural to agree with the quantity. */
+export declare function unitFor(qty: number | undefined, unit: unknown): string;
+/** "1½ cups", "400 g", "16 kg" (from 16,000 g), "2 eggs" (unit-less), or just the unit when there is no number. */
+export declare function qtyLabel(qty: unknown, unit?: unknown): string;
+export interface IngredientRow {
+    key: string;
+    name: string;
+    qty?: number;
+    unit: string;
+    note: string;
+    aisle: Aisle;
+}
+/** Ingredient rows with a name; a nameless (mid-stream, junk) row is dropped. */
+export declare function readIngredients(v: unknown): IngredientRow[];
+export interface StepRow {
+    key: string;
+    i: number;
+    text: string;
+    minutes?: number;
+    tip: string;
+}
+/** Steps with text; `i` keeps the written position so `done` indexes stay stable. */
+export declare function readSteps(v: unknown): StepRow[];
+export interface LibraryRecipe {
+    key: string;
+    /** What a meal writes to point at this recipe: the id, else the name. */
+    ref: string;
+    raw: Record<string, unknown>;
+    name: string;
+    kind?: string;
+    serves?: number;
+    kcal?: number;
+    protein?: number;
+    minutes?: number;
+}
+/** The recipe library: rows with a name or an id, in written order; a repeated ref keeps the first. */
+export declare function readLibrary(v: unknown): LibraryRecipe[];
+/** A meal's recipe by id, else by name (models often write the name). */
+export declare function findRecipe(lib: readonly LibraryRecipe[], ref: unknown): LibraryRecipe | undefined;
+export declare const dayLabel: (day: unknown, i: number) => string;
+/** Per person: the sum of each resolved meal's per-serving values. */
+export declare function dayTotals(day: unknown, lib: readonly LibraryRecipe[]): {
+    kcal?: number;
+    protein?: number;
+};
+export interface GoalCheck {
+    status: Status;
+    word: string;
+}
+/**
+ * Protein is a floor: met at 100%, close from 85%, short below.
+ * Calories are a target: on target within 10%, close within 20%, else over or under.
+ */
+export declare function goalCheck(value: number | undefined, goal: unknown, mode: 'floor' | 'target'): GoalCheck | undefined;
+export interface ShopItem {
+    key: string;
+    name: string;
+    unit: string;
+    /** Summed and scaled; undefined when no use gave a number ("to taste"). */
+    qty?: number;
+    aisle: Aisle;
+    /** How many planned meals use it. */
+    uses: number;
+}
+export declare const shopKey: (name: string, unit: string) => string;
+/**
+ * The shopping list: every planned meal's ingredients, each quantity times
+ * `people / serves`, summed by name + unit, grouped by aisle in store order and
+ * sorted by name. A meal whose recipe is missing adds nothing.
+ */
+export declare function shoppingList(days: unknown, lib: readonly LibraryRecipe[], people: number): {
+    aisle: Aisle;
+    items: ShopItem[];
+}[];
+/** A new days array with one meal pointing at another recipe; nothing is mutated. */
+export declare function swapMeal(days: unknown, di: number, mi: number, ref: string): unknown[];

package/dist/widgets/composite/recipe.js

@@ -0,0 +1,247 @@
+// widgets/composite/recipe.ts — the data rules shared by `recipe` and
+// `meal-plan` (design doc 2026-10-09 §3.6): reading model rows, scaling
+// quantities, formatting them as cooks write them, and the meal plan's sums.
+//
+// Invariants:
+// - Quantities are numbers with a separate unit. Scaling multiplies the number;
+//   nothing parses "1 1/2 cups" out of a string (ocean-flow's regex bug).
+// - Ingredient quantities scale by `people / serves`. Nutrition (`kcal`,
+//   `protein_g`) is per serving and never scales: a day's total is per person,
+//   and `goal` is per person per day.
+// - A recipe with no usable `serves` is not scaled (factor 1): its quantities
+//   are shown and summed as written rather than guessed.
+// - The shopping list sums by normalised `name|unit` ("cups" and "cup" are one
+//   unit); the same name in another unit stays its own row. That key is also what a tick (`got`) remembers, so a
+//   swap never moves a tick onto another item.
+// - Every reader takes `unknown` and never throws: props are model output.
+//   Kinds and slots compare lowercased; nutrition reads "22g" as 22 and a
+//   negative value as missing; a negative qty is missing; a repeated recipe id
+//   keeps its first row only.
+// - Grams and millilitres of 1,000 or more print as kg and l (display only;
+//   the sum key keeps the written unit).
+// - A widget's own edit of a non-bound prop (a swap, a tick) is an `Edit`
+//   (data-kit/edit.ts).
+import { finite, plain } from '../data-kit/format.js';
+export const SLOTS = ['breakfast', 'lunch', 'dinner', 'snack'];
+export const AISLES = ['produce', 'protein', 'dairy', 'grains', 'pantry', 'frozen', 'other'];
+export function rec(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+export function list(v) {
+    return Array.isArray(v) ? v : [];
+}
+export const toAisle = (v) => (AISLES.includes(v) ? v : 'other');
+const word = (s) => (s ? s[0].toUpperCase() + s.slice(1) : s);
+/** "breakfast" → "Breakfast"; an unknown slot shows as written. */
+export const slotLabel = (slot) => word(slot);
+/** A positive count, else undefined. */
+export function positive(v) {
+    const n = finite(v);
+    return n !== undefined && n > 0 ? n : undefined;
+}
+/** A nutrition value: a number, "550" or "22g" / "550 kcal"; negative or junk is missing. */
+export function nutrient(v) {
+    const n = typeof v === 'string' ? Number(/^\s*(\d+(?:\.\d+)?)\s*[a-z]*\s*$/i.exec(v)?.[1]) : finite(v);
+    return n !== undefined && Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+/** A recipe ref as words: "leftover-pizza" reads "Leftover pizza". */
+export const humanRef = (ref) => word(ref.replace(/[-_]+/g, ' ').trim());
+/** How much to multiply the written quantities by; 1 when `serves` is unusable. */
+export function scaleFactor(want, serves) {
+    const base = positive(serves);
+    const n = positive(want);
+    return base && n ? n / base : 1;
+}
+// Metric and weight units read best as decimals; cups and spoons as fractions.
+const DECIMAL_UNITS = /^(g|gr|grams?|kg|mg|ml|millilit(?:er|re)s?|l|lit(?:er|re)s?|cl|dl|oz|lbs?)$/i;
+const FRACTIONS = [
+    [1 / 8, '⅛'],
+    [1 / 4, '¼'],
+    [1 / 3, '⅓'],
+    [1 / 2, '½'],
+    [2 / 3, '⅔'],
+    [3 / 4, '¾']
+];
+function decimal(n, digits) {
+    return new Intl.NumberFormat(undefined, { maximumFractionDigits: digits }).format(n);
+}
+/**
+ * A quantity as a cook writes it: 1.5 cups → "1½", 0.333 tsp → "⅓",
+ * 562.5 g → "563", 1.25 kg → "1.25". Missing or non-finite → ''.
+ */
+export function formatQty(qty, unit) {
+    const q = finite(qty);
+    if (q === undefined || q < 0)
+        return '';
+    if (typeof unit === 'string' && DECIMAL_UNITS.test(unit.trim()))
+        return decimal(q, q >= 10 ? 0 : 2);
+    if (q >= 20)
+        return decimal(q, 0);
+    const whole = Math.floor(q);
+    const rest = q - whole;
+    if (rest < 0.04)
+        return whole ? String(whole) : decimal(q, 2);
+    if (rest > 0.96)
+        return String(whole + 1);
+    const near = FRACTIONS.find(([v]) => Math.abs(rest - v) < 0.04);
+    return near ? `${whole || ''}${near[1]}` : decimal(q, 2);
+}
+// Counted units read singular at one and plural above it ("1 can", "2 cans");
+// a model writes either form. tbsp, tsp and metric units never change.
+const COUNTED = new Set(['cup', 'can', 'clove', 'slice', 'head', 'jar', 'bunch', 'pinch', 'sprig', 'stick', 'pack', 'bag', 'fillet', 'piece', 'tin', 'handful', 'bottle', 'scoop', 'stalk']);
+const singular = (u) => (u.endsWith('es') && COUNTED.has(u.slice(0, -2)) ? u.slice(0, -2) : u.endsWith('s') && COUNTED.has(u.slice(0, -1)) ? u.slice(0, -1) : u);
+/** The unit a sum is kept under: lowercased, a counted unit in its singular. */
+export function baseUnit(unit) {
+    return singular(plain(unit).toLowerCase());
+}
+/** The unit as written, made singular or plural to agree with the quantity. */
+export function unitFor(qty, unit) {
+    const u = plain(unit);
+    const one = singular(u.toLowerCase());
+    if (qty === undefined || !COUNTED.has(one))
+        return u;
+    return qty > 1 ? (/(ch|sh)$/.test(one) ? `${one}es` : `${one}s`) : one;
+}
+const GRAMS = /^(g|gr|grams?)$/;
+const MILLILITRES = /^(ml|millilit(?:er|re)s?)$/;
+/** "1½ cups", "400 g", "16 kg" (from 16,000 g), "2 eggs" (unit-less), or just the unit when there is no number. */
+export function qtyLabel(qty, unit) {
+    let q = finite(qty);
+    const big = q !== undefined && q >= 1000;
+    if (big && GRAMS.test(baseUnit(unit)))
+        [q, unit] = [q / 1000, 'kg'];
+    else if (big && MILLILITRES.test(baseUnit(unit)))
+        [q, unit] = [q / 1000, 'l'];
+    const n = formatQty(q, unit);
+    // Agree with the number as printed: 1.02 prints "1", so "1 cup".
+    return [n, unitFor(n ? (n === '1' ? 1 : q) : undefined, unit)].filter(Boolean).join(' ');
+}
+/** Ingredient rows with a name; a nameless (mid-stream, junk) row is dropped. */
+export function readIngredients(v) {
+    return list(v).flatMap((raw, i) => {
+        const r = rec(raw);
+        const name = plain(r.name);
+        if (!name)
+            return [];
+        const qty = finite(r.qty);
+        return [{ key: `${plain(r.id)}:${i}`, name, qty: qty !== undefined && qty >= 0 ? qty : undefined, unit: plain(r.unit), note: plain(r.note), aisle: toAisle(r.aisle) }];
+    });
+}
+/** Steps with text; `i` keeps the written position so `done` indexes stay stable. */
+export function readSteps(v) {
+    return list(v).flatMap((raw, i) => {
+        const r = typeof raw === 'string' ? { text: raw } : rec(raw);
+        const text = plain(r.text);
+        if (!text)
+            return [];
+        return [{ key: `${plain(r.id)}:${i}`, i, text, minutes: positive(r.minutes), tip: plain(r.tip) }];
+    });
+}
+/** The recipe library: rows with a name or an id, in written order; a repeated ref keeps the first. */
+export function readLibrary(v) {
+    const seen = new Set();
+    return list(v).flatMap((raw, i) => {
+        const r = rec(raw);
+        const id = plain(r.id);
+        const name = plain(r.name);
+        if ((!id && !name) || seen.has(id || name))
+            return [];
+        seen.add(id || name);
+        return [
+            {
+                key: `${id}:${i}`,
+                ref: id || name,
+                raw: r,
+                name: name || id,
+                kind: plain(r.kind).toLowerCase() || undefined,
+                serves: positive(r.serves),
+                kcal: nutrient(r.kcal),
+                protein: nutrient(r.protein_g),
+                minutes: positive(r.minutes)
+            }
+        ];
+    });
+}
+/** A meal's recipe by id, else by name (models often write the name). */
+export function findRecipe(lib, ref) {
+    const s = plain(ref);
+    if (!s)
+        return undefined;
+    const lower = s.toLowerCase();
+    return lib.find((r) => plain(r.raw.id) === s) ?? lib.find((r) => r.name.toLowerCase() === lower);
+}
+export const dayLabel = (day, i) => {
+    const d = rec(day);
+    return plain(d.day) || plain(d.label) || `Day ${i + 1}`;
+};
+/** Per person: the sum of each resolved meal's per-serving values. */
+export function dayTotals(day, lib) {
+    let kcal;
+    let protein;
+    for (const m of list(rec(day).meals)) {
+        const r = findRecipe(lib, rec(m).recipe);
+        if (r?.kcal !== undefined)
+            kcal = (kcal ?? 0) + r.kcal;
+        if (r?.protein !== undefined)
+            protein = (protein ?? 0) + r.protein;
+    }
+    return { kcal, protein };
+}
+/**
+ * Protein is a floor: met at 100%, close from 85%, short below.
+ * Calories are a target: on target within 10%, close within 20%, else over or under.
+ */
+export function goalCheck(value, goal, mode) {
+    const g = positive(goal);
+    if (value === undefined || !g)
+        return undefined;
+    const r = value / g;
+    if (mode === 'floor') {
+        return r >= 1 ? { status: 'good', word: 'Goal met' } : r >= 0.85 ? { status: 'warn', word: 'Close' } : { status: 'bad', word: 'Short' };
+    }
+    const off = Math.abs(r - 1);
+    if (off <= 0.1)
+        return { status: 'good', word: 'On target' };
+    if (off <= 0.2)
+        return { status: 'warn', word: 'Close' };
+    return { status: 'bad', word: r > 1 ? 'Over' : 'Under' };
+}
+export const shopKey = (name, unit) => `${name.trim().toLowerCase()}|${baseUnit(unit)}`;
+/**
+ * The shopping list: every planned meal's ingredients, each quantity times
+ * `people / serves`, summed by name + unit, grouped by aisle in store order and
+ * sorted by name. A meal whose recipe is missing adds nothing.
+ */
+export function shoppingList(days, lib, people) {
+    const items = new Map();
+    for (const day of list(days)) {
+        for (const m of list(rec(day).meals)) {
+            const r = findRecipe(lib, rec(m).recipe);
+            if (!r)
+                continue;
+            const f = scaleFactor(people, r.serves);
+            for (const ing of readIngredients(r.raw.ingredients)) {
+                const key = shopKey(ing.name, ing.unit);
+                let item = items.get(key);
+                if (!item) {
+                    item = { key, name: ing.name, unit: ing.unit, aisle: ing.aisle, uses: 0 };
+                    items.set(key, item);
+                }
+                if (ing.qty !== undefined && ing.qty >= 0)
+                    item.qty = (item.qty ?? 0) + ing.qty * f;
+                if (item.aisle === 'other')
+                    item.aisle = ing.aisle;
+                item.uses++;
+            }
+        }
+    }
+    const all = [...items.values()];
+    return AISLES.map((aisle) => ({
+        aisle,
+        items: all.filter((i) => i.aisle === aisle).toSorted((a, b) => a.name.localeCompare(b.name))
+    })).filter((g) => g.items.length);
+}
+/** A new days array with one meal pointing at another recipe; nothing is mutated. */
+export function swapMeal(days, di, mi, ref) {
+    return list(days).map((d, i) => i !== di ? d : { ...rec(d), meals: list(rec(d).meals).map((m, j) => (j === mi ? { ...rec(m), recipe: ref } : m)) });
+}

package/dist/widgets/composite/standup-board.d.ts

@@ -0,0 +1,48 @@
+import type { Verdict } from '../data-kit/types.js';
+export declare const MAX_PEOPLE = 20;
+export type StandupStatus = 'blocked' | 'on-track' | 'done' | 'away';
+export interface Person {
+    id: string;
+    name: string;
+    role: string;
+    avatar: string;
+    yesterday: string;
+    today: string;
+    /** The blocker sentence, '' when blocked with no detail or not blocked. */
+    blocker: string;
+    status: StandupStatus;
+}
+export interface StandupValue {
+    resolved: string[];
+}
+/** A model status word onto the four; unknown or missing is on-track. */
+export declare const toStandupStatus: (v: unknown) => StandupStatus;
+/** Blocker text that means "no blocker" ("none", "n/a", "-") reads as ''. */
+export declare function blockerText(v: unknown): string;
+export declare const slug: (name: string) => string;
+/** People from `people` (or `members`), at most MAX_PEOPLE, plus how many more there were. */
+export declare function readPeople(people: unknown, members?: unknown): {
+    people: Person[];
+    more: number;
+};
+/** Blocked, on track, done, away; model order kept inside each group. */
+export declare const ordered: (people: readonly Person[]) => Person[];
+/** Blocked people whose blocker the viewer has not resolved. */
+export declare const openBlocked: (people: readonly Person[], resolved: readonly string[]) => Person[];
+/** The bound value, cleaned; undefined when it carries no resolved list. */
+export declare function toValue(raw: unknown): StandupValue | undefined;
+/** First and last initials, as AvatarGroup does. */
+export declare function initials(name: string): string;
+/** A stable hue for a name's initials tint, never in the brand-blue band (200 to 280). */
+export declare function nameHue(name: string): number;
+/**
+ * What a blocker waits on, as a clause for the verdict: "staging DB creds"
+ * from "Waiting on staging DB creds from infra." Empty when the blocker does
+ * not open with a waiting-on phrase or the thing runs past six words, so the
+ * verdict never cuts a sentence mid-way.
+ */
+export declare function blockedOn(text: string): string;
+/** The derived headline when the model wrote no summary. */
+export declare function deriveVerdict(people: readonly Person[], resolved: readonly string[]): Required<Verdict> | undefined;
+/** The phone layout folds each blocked person's Today when this many are blocked. */
+export declare const manyBlocked: (blocked: number, total: number) => boolean;

package/dist/widgets/composite/standup-board.js

@@ -0,0 +1,171 @@
+// widgets/composite/standup-board.ts: the pure half of the standup-board
+// widget. It turns the model's people (forgiving about shape, synonyms and
+// junk) into clean rows, orders them blocked, on track, done, away, derives
+// the open-blocker count and the verdict sentence, and reads the bound value.
+//
+// Invariants:
+// - A real blocker wins: blocker text makes a person blocked whatever their
+//   status says. `status: 'blocked'` with no text is blocked with no detail.
+// - The open count and the verdict are derived from people + resolved ids,
+//   never stored. Resolving is an overlay: the model's people are not edited.
+// - Ids are the slugified name, with -2, -3 on repeats, so `value.resolved`
+//   survives a re-sent spec with the same people.
+import { plain } from '../data-kit/format.js';
+import { list, rec } from './recipe.js';
+export const MAX_PEOPLE = 20;
+const NO_BLOCKER = new Set(['', 'none', 'n/a', 'na', '-', 'no', 'nope', 'nothing', 'no blockers', 'null']);
+const SYNONYMS = {
+    blocked: 'blocked',
+    stuck: 'blocked',
+    'on-track': 'on-track',
+    on_track: 'on-track',
+    ontrack: 'on-track',
+    'on track': 'on-track',
+    ok: 'on-track',
+    active: 'on-track',
+    done: 'done',
+    complete: 'done',
+    completed: 'done',
+    shipped: 'done',
+    away: 'away',
+    ooo: 'away',
+    out: 'away',
+    off: 'away',
+    pto: 'away',
+    leave: 'away'
+};
+/** A model status word onto the four; unknown or missing is on-track. */
+export const toStandupStatus = (v) => SYNONYMS[plain(v).toLowerCase()] ?? 'on-track';
+/** Blocker text that means "no blocker" ("none", "n/a", "-") reads as ''. */
+export function blockerText(v) {
+    const t = plain(v);
+    return NO_BLOCKER.has(t.toLowerCase().replace(/[.!]+$/, '')) ? '' : t;
+}
+export const slug = (name) => name
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '') || 'person';
+/** People from `people` (or `members`), at most MAX_PEOPLE, plus how many more there were. */
+export function readPeople(people, members) {
+    const raw = Array.isArray(people) ? people : list(members);
+    const out = [];
+    const seen = new Map();
+    let more = 0;
+    for (const r of raw) {
+        const p = typeof r === 'string' ? { name: r } : rec(r);
+        const name = plain(p.name);
+        if (!name)
+            continue;
+        if (out.length >= MAX_PEOPLE) {
+            more++;
+            continue;
+        }
+        const base = slug(name);
+        const n = (seen.get(base) ?? 0) + 1;
+        seen.set(base, n);
+        const blocker = blockerText(p.blocker ?? p.blockers);
+        const said = toStandupStatus(p.status);
+        out.push({
+            id: n > 1 ? `${base}-${n}` : base,
+            name,
+            role: plain(p.role),
+            avatar: typeof p.avatar === 'string' ? p.avatar.trim() : '',
+            yesterday: plain(p.yesterday),
+            today: plain(p.today),
+            blocker,
+            status: blocker ? 'blocked' : said
+        });
+    }
+    return { people: out, more };
+}
+const ORDER = { blocked: 0, 'on-track': 1, done: 2, away: 3 };
+/** Blocked, on track, done, away; model order kept inside each group. */
+export const ordered = (people) => people
+    .map((p, i) => [p, i])
+    .sort((a, b) => ORDER[a[0].status] - ORDER[b[0].status] || a[1] - b[1])
+    .map(([p]) => p);
+/** Blocked people whose blocker the viewer has not resolved. */
+export const openBlocked = (people, resolved) => people.filter((p) => p.status === 'blocked' && !resolved.includes(p.id));
+/** The bound value, cleaned; undefined when it carries no resolved list. */
+export function toValue(raw) {
+    const r = rec(raw);
+    if (!Array.isArray(r.resolved))
+        return undefined;
+    return { resolved: [...new Set(r.resolved.filter((v) => typeof v === 'string' && v !== ''))] };
+}
+/** First and last initials, as AvatarGroup does. */
+export function initials(name) {
+    const parts = name.trim().split(/\s+/).filter(Boolean);
+    if (!parts.length)
+        return '';
+    const first = Array.from(parts[0])[0] ?? '';
+    const last = parts.length > 1 ? (Array.from(parts[parts.length - 1])[0] ?? '') : '';
+    return (first + last).toUpperCase();
+}
+/** A stable hue for a name's initials tint, never in the brand-blue band (200 to 280). */
+export function nameHue(name) {
+    let h = 0;
+    for (const ch of name)
+        h = (h * 31 + ch.codePointAt(0)) >>> 0;
+    const free = 280; // 360 minus the 80-degree blue band
+    const x = h % free;
+    return x < 200 ? x : x + 80;
+}
+const firstName = (p, all) => {
+    const f = p.name.split(/\s+/)[0];
+    return all.filter((q) => q.name.split(/\s+/)[0] === f).length > 1 ? p.name : f;
+};
+const LEAD = /^(?:still\s+)?(?:waiting\s+(?:on|for)|blocked\s+(?:on|by)|stuck\s+on|held\s+up\s+(?:on|by)|depends\s+on|needs?)\s+/i;
+const BREAK = /[,.;:!?()]|\s(?:from|to|until|till|because|since|so|which|that|before|after|while|but|for)\s/i;
+const TAIL = /\s+(?:the|a|an|of|on|to|from|with|for|and|or|in)$/i;
+/**
+ * What a blocker waits on, as a clause for the verdict: "staging DB creds"
+ * from "Waiting on staging DB creds from infra." Empty when the blocker does
+ * not open with a waiting-on phrase or the thing runs past six words, so the
+ * verdict never cuts a sentence mid-way.
+ */
+export function blockedOn(text) {
+    const lead = text.match(LEAD);
+    if (!lead)
+        return '';
+    let rest = text.slice(lead[0].length);
+    const b = rest.search(BREAK);
+    if (b >= 0)
+        rest = rest.slice(0, b);
+    rest = rest.trim();
+    while (TAIL.test(rest))
+        rest = rest.replace(TAIL, '');
+    const words = rest.split(/\s+/).filter(Boolean);
+    if (!words.length || words.length > 6)
+        return '';
+    const w = words[0];
+    if (w.length > 1 && w[1] === w[1].toLowerCase())
+        words[0] = w[0].toLowerCase() + w.slice(1);
+    return words.join(' ');
+}
+const joinNames = (names) => (names.length < 2 ? names.join('') : `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`);
+/** The derived headline when the model wrote no summary. */
+export function deriveVerdict(people, resolved) {
+    if (!people.length)
+        return undefined;
+    const open = openBlocked(people, resolved);
+    const silent = people.every((p) => !p.yesterday && !p.today && p.status !== 'blocked' && p.status !== 'away' && p.status !== 'done');
+    if (silent)
+        return { text: 'No updates yet.', status: 'neutral' };
+    if (!open.length)
+        return { text: 'Everyone is unblocked.', status: 'good' };
+    if (open.length === 1) {
+        const p = open[0];
+        const who = firstName(p, people);
+        const on = blockedOn(p.blocker);
+        return { text: on ? `${who} is blocked on ${on}.` : `${who} is blocked.`, status: 'bad' };
+    }
+    if (open.length <= 3)
+        return { text: `${joinNames(open.map((p) => firstName(p, people)))} are blocked.`, status: 'bad' };
+    const total = people.length;
+    return { text: open.length === total ? `All ${total} are blocked.` : `${open.length} of ${total} are blocked.`, status: 'bad' };
+}
+/** The phone layout folds each blocked person's Today when this many are blocked. */
+export const manyBlocked = (blocked, total) => blocked >= 4 || (total >= 5 && blocked * 2 >= total);