@peasant-labs/fairtrade 0.0.20 → 0.0.22

package/dist/lib/tokens.css

@@ -34,6 +34,7 @@
   --bp-lg: 1024px;
   --bp-xl: 1440px;
   --dialog-w: 420px;
+  --dialog-w-wide: 720px;
   --fs-label: 14px;
   --fs-sm: 14px;
   --fs-body: 16px;

package/dist/lib/tokens.json

@@ -590,6 +590,10 @@
       "$type": "other",
       "$value": "420px"
     },
+    "dialog-w-wide": {
+      "$type": "other",
+      "$value": "720px"
+    },
     "menu-min-w": {
       "$type": "other",
       "$value": "256px"

package/dist/lib/types/ConnectionState.d.ts

@@ -79,4 +79,30 @@ export function TeachingEmptyState({ icon: Icon, title, body, command, privacy,
     as?: keyof JSX.IntrinsicElements;
     className?: string;
 }): import("react").JSX.Element;
+/**
+ * LocalOfflineBanner — the page-level notice for "the peasant app on this computer stopped". It
+ * says what is wrong in plain words (the local program, not the internet), gives the command that
+ * starts it again in the existing copy-able command chip, and offers `try again`. There is no
+ * wifi glyph: the icon is the same unplug the lost-connection panel uses.
+ *
+ * The message is the `role="status"` live region. The command, the button and the `last checked`
+ * time sit outside it, so a retry that only moves the time never re-announces the whole banner.
+ * The command is code: mono, never lowercased. Everything else is lowercase chrome.
+ *
+ * @param {object} props
+ * @param {() => void} [props.onRetry] - `try again`; omit it and no button renders.
+ * @param {boolean} [props.retrying=false] - a retry is in flight: the button reports busy and
+ *        ignores further presses until the host clears it.
+ * @param {Date | string | number} [props.checkedAt] - when the host last checked; shown as
+ *        hh:mm:ss with tabular numbers. omitted, no time renders.
+ * @param {string} [props.command='peasant web start'] - the command that starts the local app.
+ * @param {string} [props.className]
+ */
+export function LocalOfflineBanner({ onRetry, retrying, checkedAt, command, className, ...rest }: {
+    onRetry?: () => void;
+    retrying?: boolean;
+    checkedAt?: Date | string | number;
+    command?: string;
+    className?: string;
+}): import("react").JSX.Element;
 export default ConnectionPill;

package/dist/lib/types/CopyIconButton.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {object} props
+ * @param {string} props.value - the exact text written to the clipboard.
+ * @param {string} props.label - the accessible name, a verb and an object ("copy link").
+ * @param {() => void} [props.onCopied] - called after a successful write.
+ * @param {'sm' | 'md'} [props.size='sm'] - `sm` uses the compact control height.
+ * @param {string} [props.className]
+ */
+export default function CopyIconButton({ value, label, onCopied, size, className, ...rest }: {
+    value: string;
+    label: string;
+    onCopied?: () => void;
+    size?: "sm" | "md";
+    className?: string;
+}): import("react").JSX.Element;

package/dist/lib/types/Dialog.d.ts

@@ -1,4 +1,4 @@
-export default function Dialog({ open, onClose, title, labelId, children, footer, returnFocusRef }: {
+export default function Dialog({ open, onClose, title, labelId, children, footer, returnFocusRef, size, className, dismissible }: {
     open: any;
     onClose: any;
     title: any;
@@ -6,4 +6,7 @@ export default function Dialog({ open, onClose, title, labelId, children, footer
     children: any;
     footer: any;
     returnFocusRef: any;
+    size?: string;
+    className?: string;
+    dismissible?: boolean;
 }): import("react").JSX.Element;

package/dist/lib/types/GroupedMultiSelect.d.ts

@@ -2,7 +2,7 @@
  * A grouped tri-state multi-select tree. See GroupedMultiSelectProps.
  * @param {GroupedMultiSelectProps} props
  */
-export default function GroupedMultiSelect({ groups, value, defaultValue, onChange, tokenLabel, defaultOpen, ariaLabel, }: GroupedMultiSelectProps): import("react").JSX.Element;
+export default function GroupedMultiSelect({ groups, value, defaultValue, onChange, tokenLabel, defaultOpen, ariaLabel, searchable, searchLabel, }: GroupedMultiSelectProps): import("react").JSX.Element;
 export type GMSItem = {
     /**
      * unique selection id (what lands in the value Set).
@@ -20,6 +20,10 @@ export type GMSItem = {
      * token count for the running tally; defaults to 0.
      */
     tokens?: number;
+    /**
+     * the text a search matches; defaults to a string `label`.
+     */
+    searchText?: string;
 };
 export type GMSGroup = {
     /**
@@ -64,4 +68,14 @@ export type GroupedMultiSelectProps = {
      * accessible name for the tree container.
      */
     ariaLabel?: string;
+    /**
+     * adds a search field and a clear button: the search
+     * filters items (by `searchText`, else a string `label`), hides groups left empty,
+     * opens the groups that match, and select all / clear act on the visible items only.
+     */
+    searchable?: boolean;
+    /**
+     * the search field's label.
+     */
+    searchLabel?: string;
 };

package/dist/lib/types/Menu.d.ts

@@ -13,18 +13,24 @@
  * Menu - a dropdown menu controlled by a single trigger button.
  *
  * @param {Object} props
- * @param {React.ReactNode} props.label             trigger label (lowercase chrome by default)
+ * @param {React.ReactNode} [props.label]           trigger label (lowercase chrome by default); omit it with `icon`
  * @param {MenuItem[]} [props.items=[]]             menu rows
  * @param {'start'|'end'} [props.align='start']     which edge of the trigger the popout aligns to
  * @param {React.ReactNode} [props.caption]         optional .menu-cap caption rendered inside the popout before the list
  * @param {boolean} [props.defaultOpen=false]       render with the popout already open (specimen / screenshot state)
+ * @param {React.ComponentType<any>} [props.icon]   icon-only trigger: the glyph replaces the label and the caret
+ * @param {string} [props.ariaLabel]               the trigger's accessible name; required with `icon`, and the menu's name
+ * @param {'sm'|'md'} [props.size='md']             `sm` uses the compact control height (header rows)
  */
-export default function Menu({ label, items, align, caption, defaultOpen }: {
-    label: React.ReactNode;
+export default function Menu({ label, items, align, caption, defaultOpen, icon: TriggerIcon, ariaLabel, size }: {
+    label?: React.ReactNode;
     items?: MenuItem[];
     align?: "start" | "end";
     caption?: React.ReactNode;
     defaultOpen?: boolean;
+    icon?: React.ComponentType<any>;
+    ariaLabel?: string;
+    size?: "sm" | "md";
 }): import("react").JSX.Element;
 export type MenuItem = {
     /**

package/dist/lib/types/OverflowList.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {object} props
+ * @param {import('react').ReactNode[]} props.items - the host's item nodes, in order.
+ * @param {number} [props.limit=2] - how many items show before the `+N` button.
+ * @param {string} props.label - the list's accessible name ("pull requests").
+ * @param {[string, string]} [props.noun=['item', 'items']] - singular and plural for the button's name.
+ * @param {import('react').ReactNode} [props.empty=null] - rendered when there are no items.
+ * @param {string} [props.className]
+ */
+export default function OverflowList({ items, limit, label, noun, empty, className, ...rest }: {
+    items: import("react").ReactNode[];
+    limit?: number;
+    label: string;
+    noun?: [string, string];
+    empty?: import("react").ReactNode;
+    className?: string;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode>>;

package/dist/lib/types/PromptDigest.d.ts

@@ -14,12 +14,26 @@
  *        wire data). when given, every prompt row's avatar renders the writer's GitHub profile
  *        photo via the existing `Avatar` family; when omitted, prompt rows keep today's generic
  *        glyph.
+ * @param {'stacked' | 'split'} [props.layout='stacked'] - `stacked` renders the one chain with its
+ *        session boundaries as separators; `split` lists the sessions beside a reading pane that
+ *        shows the selected session's prompts.
+ * @param {number} [props.selected] - split layout only: the selected entry's position in the list
+ *        (controlled). The list has one entry per session boundary, in chain order, plus a leading
+ *        entry at 0 when items precede the first boundary. It is a position, not a transcript id,
+ *        because the same transcript can open more than one entry. Keep the index `onSelect`
+ *        reports. Omit it and the component keeps its own selection, starting at the first.
+ * @param {(index: number, session: PromptDigestItemPayload | null) => void} [props.onSelect] - split
+ *        layout only: called with the next index and its session boundary item (null for the
+ *        leading entry of items that precede every boundary).
  * @param {string} [props.className] - extra classes appended after `.pd`
  */
-export default function PromptDigest({ digest, itemHref, author, className, ...rest }: {
+export default function PromptDigest({ digest, itemHref, author, layout, selected, onSelect, className, ...rest }: {
     digest: PromptDigestPayload;
     itemHref?: (item: PromptDigestItemPayload) => string;
     author?: PromptAuthor;
+    layout?: "stacked" | "split";
+    selected?: number;
+    onSelect?: (index: number, session: PromptDigestItemPayload | null) => void;
     className?: string;
 }): import("react").JSX.Element;
 export type PromptDigestPayload = import("@peasant-labs/schema").PromptDigest;

package/dist/lib/types/Publish.d.ts

@@ -0,0 +1,211 @@
+/**
+ * PublishStateLabel — the transcript's publish state: an icon and its words.
+ *
+ * @param {object} props
+ * @param {PublishState} props.state
+ * @param {number} [props.collectives] - how many collectives can read it (published, new-turns, publishing); left out of the words when omitted.
+ * @param {number} [props.newTurns] - turns recorded since the last publish (new-turns).
+ * @param {string} [props.collective] - the collective(s) the project's auto-publish rule targets (auto-publish).
+ * @param {string} [props.className]
+ */
+export function PublishStateLabel({ state, collectives, newTurns, collective, className, ...rest }: {
+    state: PublishState;
+    collectives?: number;
+    newTurns?: number;
+    collective?: string;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * PublishBar — the status and the one action for it, for a transcript header row. The action is
+ * publish (not published, outside the saved lists), update (new turns) or manage (published,
+ * auto-publish on); while publishing it stays visible and busy.
+ *
+ * @param {object} props
+ * @param {PublishState} props.state - a PublishStateLabel state.
+ * @param {number} [props.collectives]
+ * @param {number} [props.newTurns]
+ * @param {string} [props.collective]
+ * @param {() => void} [props.onAction] - the one button. omit it and no button renders.
+ * @param {string} [props.actionLabel] - replaces the state's default label.
+ * @param {import('./Menu.jsx').MenuItem[]} [props.moreItems] - an optional overflow menu after the button.
+ * @param {string} [props.className]
+ */
+export function PublishBar({ state, collectives, newTurns, collective, onAction, actionLabel, moreItems, className, ...rest }: {
+    state: PublishState;
+    collectives?: number;
+    newTurns?: number;
+    collective?: string;
+    onAction?: () => void;
+    actionLabel?: string;
+    moreItems?: import("./Menu.jsx").MenuItem[];
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * AccessList — who can read the transcript: one row per collective with a named remove button.
+ * A row pending removal says so and offers `keep` instead.
+ *
+ * @param {object} props
+ * @param {AccessItem[]} props.items
+ * @param {(id: string) => void} [props.onRemove] - the row's x; omit it for a read-only list.
+ * @param {(id: string) => void} [props.onRestore] - `keep` on a row pending removal.
+ * @param {import('react').ReactNode} [props.empty] - shown when no collective can read it.
+ * @param {string} [props.label='who can read it']
+ * @param {string} [props.className]
+ */
+export function AccessList({ items, onRemove, onRestore, empty, label, className, ...rest }: {
+    items: AccessItem[];
+    onRemove?: (id: string) => void;
+    onRestore?: (id: string) => void;
+    empty?: import("react").ReactNode;
+    label?: string;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * CollectivePicker — search and suggestions for adding a collective. The host searches (village
+ * knows the collectives) and passes the results as `suggestions`; the picker renders them and
+ * reports the query and the choice.
+ *
+ * @param {object} props
+ * @param {{ id: string, name: string, members?: number, note?: string }[]} props.suggestions
+ * @param {(id: string) => void} props.onAdd
+ * @param {string} [props.query] - controlled query; omit it to let the picker keep its own.
+ * @param {(query: string) => void} [props.onQueryChange]
+ * @param {string} [props.label='add a collective'] - the field's label.
+ * @param {string} [props.placeholder='collective or github org']
+ * @param {import('react').ReactNode} [props.empty] - shown for a query with no suggestions.
+ * @param {string} [props.className]
+ */
+export function CollectivePicker({ suggestions, onAdd, query: queryProp, onQueryChange, label, placeholder, empty, className, ...rest }: {
+    suggestions: {
+        id: string;
+        name: string;
+        members?: number;
+        note?: string;
+    }[];
+    onAdd: (id: string) => void;
+    query?: string;
+    onQueryChange?: (query: string) => void;
+    label?: string;
+    placeholder?: string;
+    empty?: import("react").ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * PublishDialog — the one publish popup, for a first publish (`mode="publish"`) and an update
+ * (`mode="update"`). It shows what leaves the machine, who can read it, and the auto-publish
+ * checkbox, then the done state with the village link. The host drives `state`; the popup never
+ * advances on its own.
+ *
+ * States: `connect` (this computer is not signed in to village), `waiting-github` (after continue
+ * with github), `checking` (the redaction check is running), `scan-failed` (publish is off,
+ * re-scan stays on), `no-collective` (signed in, in no collective), `ready`, `publishing`,
+ * `stopped` (a named step failed; village keeps what it had), `done`, `waits-approval` (done, and
+ * a curated collective shows it once its owner approves).
+ *
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {() => void} props.onClose - cancel, the close button, Escape and the scrim.
+ * @param {string} props.title - the session title, kept in its case.
+ * @param {'publish'|'update'} [props.mode='publish']
+ * @param {PublishDialogState} props.state - one of PUBLISH_DIALOG_STATES.
+ * @param {{ matches?: object[], total?: number, failure?: string }} [props.scan] - the host's scan result. Until it carries a
+ *        `matches` list, the popup says the transcript is not scanned and keeps publish off. A match with `kept: true` leaves un-redacted, and the
+ *        popup says so and opens the matches.
+ * @param {() => void} [props.onRescan]
+ * @param {{ summary: string }} [props.changes] - update mode: what changed since the last publish.
+ * @param {AccessItem[]} [props.access] - who can read it after this publish.
+ * @param {(id: string) => void} [props.onRemove]
+ * @param {(id: string) => void} [props.onRestore]
+ * @param {object} [props.picker] - CollectivePicker props (suggestions, onAdd, query, onQueryChange).
+ * @param {{ checked: boolean, onChange: (checked: boolean) => void, hint?: string }} [props.autoPublish]
+ * @param {string} [props.accessSummary] - update mode: the access change in words ("adds ML Reading Group · removes nothing").
+ * @param {string} [props.primaryLabel] - replaces the derived primary label.
+ * @param {() => void} [props.onPublish]
+ * @param {() => void} [props.onConnect] - `continue with github`.
+ * @param {string} [props.joinHref] - `create or join one on village`.
+ * @param {string} [props.stoppedAt] - the step that failed, in words ("setting who can read it").
+ * @param {() => void} [props.onRetry]
+ * @param {{ url: string, collectives: string[], pending?: string[], pullRequest?: { number: number, branch: string, href?: string } }} [props.done]
+ */
+export function PublishDialog({ open, onClose, title, mode, state, scan, onRescan, changes, access, onRemove, onRestore, picker, autoPublish, accessSummary, primaryLabel, onPublish, onConnect, joinHref, stoppedAt, onRetry, done, }: {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    mode?: "publish" | "update";
+    state: PublishDialogState;
+    scan?: {
+        matches?: object[];
+        total?: number;
+        failure?: string;
+    };
+    onRescan?: () => void;
+    changes?: {
+        summary: string;
+    };
+    access?: AccessItem[];
+    onRemove?: (id: string) => void;
+    onRestore?: (id: string) => void;
+    picker?: object;
+    autoPublish?: {
+        checked: boolean;
+        onChange: (checked: boolean) => void;
+        hint?: string;
+    };
+    accessSummary?: string;
+    primaryLabel?: string;
+    onPublish?: () => void;
+    onConnect?: () => void;
+    joinHref?: string;
+    stoppedAt?: string;
+    onRetry?: () => void;
+    done?: {
+        url: string;
+        collectives: string[];
+        pending?: string[];
+        pullRequest?: {
+            number: number;
+            branch: string;
+            href?: string;
+        };
+    };
+}): import("react").JSX.Element;
+/**
+ * A transcript's publish state. `auto-publish` states the rule for the project, not how this
+ * transcript was published.
+ * @typedef {'not-published'|'publishing'|'published'|'new-turns'|'auto-publish'|'outside-lists'} PublishState
+ */
+/** Every PublishState, in order. @type {ReadonlyArray<PublishState>} */
+export const PUBLISH_STATES: ReadonlyArray<PublishState>;
+/**
+ * A state of the publish popup.
+ * @typedef {'connect'|'waiting-github'|'checking'|'scan-failed'|'no-collective'|'ready'|'publishing'|'stopped'|'done'|'waits-approval'} PublishDialogState
+ */
+/** Every state the popup reaches, in the order a first publish meets them. @type {ReadonlyArray<PublishDialogState>} */
+export const PUBLISH_DIALOG_STATES: ReadonlyArray<PublishDialogState>;
+/**
+ * A transcript's publish state. `auto-publish` states the rule for the project, not how this
+ * transcript was published.
+ */
+export type PublishState = "not-published" | "publishing" | "published" | "new-turns" | "auto-publish" | "outside-lists";
+export type AccessItem = {
+    id: string;
+    /**
+     * - the collective's name, kept in its case.
+     */
+    name: string;
+    members?: number;
+    /**
+     * - why it is here ("suggested · repo acme/ingest-api is linked").
+     */
+    note?: string;
+    /**
+     * - a change the next publish or update makes:
+     * `adding` (joins on publish), `approval` (joins once its owner approves), `removal`
+     * (loses access on update). stated in words on the row.
+     */
+    pending?: "adding" | "approval" | "removal";
+};
+/**
+ * A state of the publish popup.
+ */
+export type PublishDialogState = "connect" | "waiting-github" | "checking" | "scan-failed" | "no-collective" | "ready" | "publishing" | "stopped" | "done" | "waits-approval";

package/dist/lib/types/Redaction.d.ts

@@ -16,9 +16,11 @@
  * @param {number} [props.scanned] - sessions/files scanned so far (defaults to `total`: done).
  * @param {number} [props.total=0] - total to scan.
  * @param {string|boolean} [props.failure] - honest-failure banner text; truthy shows the banner.
+ * @param {boolean} [props.readOnly=false] - show each match's decision without the keep/revert
+ *        button; nothing in the review changes state. `onToggle` is ignored.
  * @param {string} [props.className]
  */
-export function RedactionReview({ level, availableLevels, onLevel, matches, onToggle, scanned, total, failure, className, ...rest }: {
+export function RedactionReview({ level, availableLevels, onLevel, matches, onToggle, scanned, total, failure, readOnly, className, ...rest }: {
     level?: "minimal" | "standard" | "maximum";
     availableLevels?: readonly ("minimal" | "standard" | "maximum")[];
     onLevel?: (level: "minimal" | "standard" | "maximum") => void;
@@ -35,6 +37,7 @@ export function RedactionReview({ level, availableLevels, onLevel, matches, onTo
     scanned?: number;
     total?: number;
     failure?: string | boolean;
+    readOnly?: boolean;
     className?: string;
 }): import("react").JSX.Element;
 /**

package/dist/lib/types/RepoPicker.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @param {object} props
+ * @param {boolean} props.open
+ * @param {() => void} props.onClose
+ * @param {RepoPickerOwner[]} props.owners
+ * @param {string[]} [props.initialSelected] - the repositories linked when the popup opens.
+ * @param {(diff: { add: string[], remove: string[] }) => void} props.onSave
+ * @param {string} [props.title='link repositories']
+ * @param {import('react').ReactNode} [props.description] - one line under the title.
+ * @param {boolean} [props.saving=false] - the host's write is in flight.
+ * @param {string} [props.error] - the host's write failed; shown in a role="alert" line.
+ */
+export default function RepoPicker({ open, onClose, owners, initialSelected, onSave, title, description, saving, error }: {
+    open: boolean;
+    onClose: () => void;
+    owners: RepoPickerOwner[];
+    initialSelected?: string[];
+    onSave: (diff: {
+        add: string[];
+        remove: string[];
+    }) => void;
+    title?: string;
+    description?: import("react").ReactNode;
+    saving?: boolean;
+    error?: string;
+}): import("react").JSX.Element;
+export type RepoPickerOwner = {
+    id: string;
+    /**
+     * - the owner's GitHub login.
+     */
+    login: string;
+    kind: "org" | "user";
+    /**
+     * - a user's photo; an organisation shows the organisation icon.
+     */
+    avatarUrl?: string;
+    repos: {
+        id: string;
+        name: string;
+        private?: boolean;
+        note?: string;
+    }[];
+};

package/dist/lib/types/SessionGroupDisclosure.d.ts

@@ -0,0 +1,42 @@
+/**
+ * SessionGroupDisclosure - the one collapsed count control for a session list.
+ *
+ * The label names the group's membership and its count ("orphan sessions 2"),
+ * a chevron leads the control, and a trailing `show`/`hide` states what the
+ * press will do. The control is a real `<button>` with `aria-expanded` and
+ * `aria-controls`, so the row it reveals is named, not inferred.
+ *
+ * Expansion state stays with the caller: a group is an aside, and a viewer who
+ * opened it once has not asked for it to be open on every future visit. The
+ * revealed content renders only while expanded, so a folded row cannot be
+ * mistaken for a visible one and holds no page height.
+ *
+ * @param {object} props
+ * @param {import('react').ReactNode} props.label - the control's text while OPEN
+ * @param {import('react').ReactNode} props.collapsedLabel - the control's text
+ *   while CLOSED; the caller writes it, because the sibling groups do not agree
+ *   on a leading mark
+ * @param {boolean} props.expanded
+ * @param {() => void} props.onToggle
+ * @param {string} props.rowsID - the `id` of the element this control reveals;
+ *   the caller owns that element
+ * @param {boolean} [props.bare] - drop the outer border when the group sits
+ *   inside an already-bordered panel
+ * @param {boolean} [props.indent] - indent one step, so a group nested inside a
+ *   list reads as belonging to it rather than as another list row
+ * @param {string} [props.testID] - base for the wrapper and control test ids:
+ *   `<base>`, `<base>-toggle`, and `<base>-label`
+ * @param {import('react').ReactNode} [props.children] - revealed only while
+ *   expanded
+ */
+export default function SessionGroupDisclosure({ label, collapsedLabel, expanded, onToggle, rowsID, bare, indent, testID, children, }: {
+    label: import("react").ReactNode;
+    collapsedLabel: import("react").ReactNode;
+    expanded: boolean;
+    onToggle: () => void;
+    rowsID: string;
+    bare?: boolean;
+    indent?: boolean;
+    testID?: string;
+    children?: import("react").ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/types/Settings.d.ts

@@ -0,0 +1,54 @@
+/**
+ * SettingRow — one setting: a label, optional help, and one control that saves on its own.
+ *
+ * @param {object} props
+ * @param {import('react').ReactNode} props.label - the setting's name (lowercase chrome). a text
+ *        control needs a string, since its edit button is named after it.
+ * @param {import('react').ReactNode} [props.help] - one line of help under the label.
+ * @param {'switch'|'select'|'checkbox'|'text'} props.control
+ * @param {boolean|string} props.value - the saved value.
+ * @param {{ value: string, label: string, disabled?: boolean }[]} [props.options] - select only; a disabled option shows a value that cannot be picked ("not set").
+ * @param {(next: boolean|string) => Promise<void>|void} props.onCommit - the one write; reject to fail.
+ * @param {string} [props.tag] - a note on the row, shown on a Chip ("not in peasant config").
+ * @param {boolean} [props.disabled]
+ * @param {string} [props.className]
+ */
+export function SettingRow({ label, help, control, value, options, onCommit, tag, disabled, className, ...rest }: {
+    label: import("react").ReactNode;
+    help?: import("react").ReactNode;
+    control: "switch" | "select" | "checkbox" | "text";
+    value: boolean | string;
+    options?: {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+    onCommit: (next: boolean | string) => Promise<void> | void;
+    tag?: string;
+    disabled?: boolean;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * SettingGroup — a collapsible group of setting rows: a native <details> whose summary names the
+ * group and counts its rows. The host sets which groups start open.
+ *
+ * @param {object} props
+ * @param {string} props.label - the group's name (lowercase chrome).
+ * @param {boolean} [props.defaultOpen=false]
+ * @param {number|null} [props.count] - the count shown in the summary; defaults to the children.
+ *        null shows no count (a group of actions rather than settings).
+ * @param {[string, string]} [props.noun=['setting', 'settings']] - what the count counts.
+ * @param {import('react').ReactNode} [props.description] - one line under the summary when open.
+ * @param {import('react').ReactNode} props.children - the rows.
+ * @param {string} [props.className]
+ */
+export function SettingGroup({ label, defaultOpen, count, noun, description, children, className, ...rest }: {
+    label: string;
+    defaultOpen?: boolean;
+    count?: number | null;
+    noun?: [string, string];
+    description?: import("react").ReactNode;
+    children: import("react").ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export const SETTING_ROW_STATES: readonly string[];

package/dist/lib/types/SignIn.d.ts

@@ -6,7 +6,7 @@
  * primary or any menu row calls onSignIn(providerId).
  *
  * @param {object} props
- * @param {Array<{id:string,label:string}>} [props.providers] ordered; [0] is primary. defaults to PROVIDERS.
+ * @param {Array<{id:string,label:string}>} [props.providers] ordered; [0] is primary. defaults to GitHub only; pass PROVIDERS for all five.
  * @param {(id:string)=>void} [props.onSignIn] called with the chosen provider id.
  * @param {string} [props.className]
  * @returns {JSX.Element|null}

package/dist/lib/types/StatsStrip.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {object} StatsStripItem
+ * @property {string} label - lowercase chrome naming the value ("sessions", "longest streak").
+ * @property {string | number} value - the host-formatted value; a number is grouped (1284 -> 1,284).
+ * @property {'value-first' | 'label-first'} [order='value-first'] - reading order of the pair.
+ */
+/**
+ * @param {object} props
+ * @param {StatsStripItem[]} props.items - the pairs, in reading order.
+ * @param {string} [props.label='summary'] - the list's accessible name.
+ * @param {string} [props.className]
+ */
+export default function StatsStrip({ items, label, className, ...rest }: {
+    items: StatsStripItem[];
+    label?: string;
+    className?: string;
+}): import("react").JSX.Element;
+export type StatsStripItem = {
+    /**
+     * - lowercase chrome naming the value ("sessions", "longest streak").
+     */
+    label: string;
+    /**
+     * - the host-formatted value; a number is grouped (1284 -> 1,284).
+     */
+    value: string | number;
+    /**
+     * - reading order of the pair.
+     */
+    order?: "value-first" | "label-first";
+};