@crewlethq/ui 0.54.1 → 0.56.0

package/dist/ProposalCard/ProposalCard.d.ts

@@ -0,0 +1,134 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+import { type ChangeListLabels, type ChangeListRow } from '../ChangeList/index.js';
+import type { DiffListLabels } from '../DiffList/index.js';
+/**
+ * Where a proposed change stands: `pending` (waiting on the person),
+ * `stepup` (the approval needs a fresh sign-in), `applying` (approved and
+ * being carried out), `applied`, `declined`, `expired`, `stale` (what it
+ * would change moved after it was prepared) and `failed` (refused or not
+ * carried out when approved).
+ */
+export type ProposalState = 'pending' | 'stepup' | 'applying' | 'applied' | 'declined' | 'expired' | 'stale' | 'failed';
+export declare const PROPOSAL_STATES: readonly ["pending", "stepup", "applying", "applied", "declined", "expired", "stale", "failed"];
+/**
+ * Where the change lands: on the page the person is looking at (a filter on
+ * a list), which is applied, or in the company's records, which is saved.
+ * It decides the words of the busy and done states: "Applying" and "Applied",
+ * or "Saving" and "Saved".
+ */
+export type ProposalScope = 'page' | 'server';
+/** What the change does to a record: change fields of one, or create one. */
+export type ProposalKind = 'change' | 'create';
+export interface ProposalCardLabels {
+    needsApproval: string;
+    needsSignIn: string;
+    applying: string;
+    saving: string;
+    applied: string;
+    saved: string;
+    declined: string;
+    expired: string;
+    stale: string;
+    notApplied: string;
+    decline: string;
+    confirmIdentity: string;
+    prepareAgain: string;
+    tryAgain: string;
+    whatWillChange: string;
+    whatWillBeCreated: string;
+    whatChanged: string;
+    whatWasCreated: string;
+    whatWasProposed: string;
+    stepUpNotice: string;
+    declinedNotice: string;
+    expiredNotice: string;
+    staleNotice: string;
+    nothingChanged: string;
+    /** Why Decline is held while the approved change is carried out. */
+    busy: string;
+}
+export declare const PROPOSAL_CARD_LABELS: ProposalCardLabels;
+export interface ProposalCardProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    /** The action itself, in sentence case: "Filter this list", "Create task", "Share artifact". */
+    title: string;
+    /** Where the change applies, as the card's subtitle: "This list only", "Saved for the company". */
+    subtitle?: ReactNode;
+    state: ProposalState;
+    /** `server` (the default) or `page`; see `ProposalScope`. */
+    scope?: ProposalScope | undefined;
+    /** `change` (the default) or `create`, which heads the list "What will be created". */
+    kind?: ProposalKind | undefined;
+    /** What the change does, in one sentence, above the list. */
+    summary?: ReactNode;
+    /** The change, field by field (`ChangeList`). The scope is the subtitle, never a row. */
+    changes: readonly ChangeListRow[];
+    /** Replaces the list's heading, which otherwise follows `kind` and `state`. */
+    changesHeading?: ReactNode;
+    /** The consequence, in one sentence, under the list. */
+    note?: ReactNode;
+    /** The primary action, named for its effect: "Apply to this list", "Create task". Never a bare "OK". */
+    approveLabel: string;
+    /**
+     * Called by the primary action. In `stepup` the primary is "Confirm it's
+     * you" and calls this too: the host opens its sign-in check and approves
+     * again with the fresh session.
+     */
+    onApprove: () => void;
+    onDecline: () => void;
+    /** Offers "Prepare it again" on an expired or stale card. */
+    onPrepareAgain?: (() => void) | undefined;
+    /** Offers "Try again" on a failed card, where the refusal's class may succeed on a retry. */
+    onRetry?: (() => void) | undefined;
+    /** What was done, for an applied card: "Created ENG-156 · assigned to Agent SWE". */
+    receipt?: ReactNode;
+    /** Why it was not applied, for a failed card, in the engine's own sentence. "Nothing changed." follows it. */
+    failure?: ReactNode;
+    /**
+     * What the person can do next about a failure, on its own quieter line
+     * after the failure sentence and "Nothing changed.": the route's next step,
+     * such as "Ask an admin to give you access." Drawn only with `failure`.
+     */
+    failureHint?: ReactNode;
+    /**
+     * Why the primary action cannot be taken now, while the card waits on the
+     * person (`pending`) or on a fresh sign-in (`stepup`): a page action whose
+     * screen refuses the prepared change, say. The primary is held soft
+     * disabled, as Decline is held while applying, so it keeps its focus and
+     * its pointer events, says it is unavailable, and is described by this
+     * sentence, which the foot also shows above the buttons. Ignored in every
+     * other state. Decline stays available.
+     */
+    approveBlocked?: string | undefined;
+    /** Replaces the default sentence of a step-up, declined, expired or stale card. */
+    notice?: ReactNode;
+    labels?: Partial<ProposalCardLabels> | undefined;
+    /** Words for the change list. */
+    changeLabels?: Partial<ChangeListLabels> | undefined;
+    /** Words for the `DiffList` behind "Show the whole change". */
+    diffLabels?: Partial<DiffListLabels> | undefined;
+}
+/**
+ * A change prepared for the person to approve, and what became of it: one
+ * card from the moment it is proposed until it is applied, declined, expires
+ * or is refused.
+ *
+ * THE HEAD IS THE ACTION, THE TAG IS THE STATE. "Create task" with "Needs
+ * your approval", then "Saving", then "Saved". The body is a summary, the
+ * change as before and after pairs (`ChangeList`) and a one-sentence
+ * consequence; the foot is the decision, or a strip that says what happened.
+ *
+ * APPROVAL IS ALWAYS AN EXPLICIT PRESS. Nothing here takes focus when the
+ * card arrives and Enter in a composer never reaches it, so a person typing
+ * cannot approve by accident. While the approved change is carried out the
+ * primary keeps its label with the spinner in its leading slot (a button whose
+ * text becomes "Saving" has stopped saying what it does), soft disabled so
+ * focus stays on it, and Decline is held with its reason.
+ *
+ * SETTLED, THE BODY STEPS BACK. Applied, declined, expired, stale and failed
+ * cards draw their body in the secondary ink so the strip reads first, and
+ * the before and after pairs stay, so the record of what changed is there.
+ *
+ * Every sentence a refusal shows is the caller's (the engine's), never the
+ * card's own words about why.
+ */
+export declare function ProposalCard({ title, subtitle, state, scope, kind, summary, changes, changesHeading, note, approveLabel, onApprove, onDecline, onPrepareAgain, onRetry, receipt, failure, failureHint, approveBlocked, notice, labels: overrides, changeLabels, diffLabels, className, ...rest }: ProposalCardProps): import("react").JSX.Element;

package/dist/ProposalCard/index.d.ts

@@ -0,0 +1,3 @@
+import './ProposalCard.css';
+export { PROPOSAL_CARD_LABELS, PROPOSAL_STATES, ProposalCard } from './ProposalCard.js';
+export type { ProposalCardLabels, ProposalCardProps, ProposalKind, ProposalScope, ProposalState } from './ProposalCard.js';

package/dist/ProposalCard/index.js

@@ -0,0 +1,17 @@
+export { PROPOSAL_CARD_LABELS, PROPOSAL_STATES, ProposalCard } from '../chunk-E4DZOE55.js';
+import '../chunk-XQI2OUV4.js';
+import '../chunk-WDIVALLP.js';
+import '../chunk-NEHSV55H.js';
+import '../chunk-Z3GDMNMU.js';
+import '../chunk-KYIAFNU7.js';
+import '../chunk-WIATRXEJ.js';
+import '../chunk-INHXF2CL.js';
+import '../chunk-AV2DXAEL.js';
+import '../chunk-GG4QZWMQ.js';
+import '../chunk-TFGCNBWP.js';
+import '../chunk-BHHIIK3M.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/ProposalCard-HLB3FNLA.css

@@ -0,0 +1,19 @@
+/*
+ * A proposed change. The card, its head, its strip and its foot are
+ * StatusCard's; only the note's register is said here: the consequence is a
+ * quieter sentence than the summary it follows.
+ */
+.crewlet-proposal-card__note {
+  color: var(--color-text-secondary);
+}
+
+/* WHY THE PRIMARY IS HELD, on a line of its own above the decision and at
+   its end, in the foot's quiet register, so it wraps rather than pushing the
+   buttons apart. */
+.crewlet-proposal-card__blocked {
+  flex: 1 1 100%;
+  margin: 0;
+  color: var(--color-text-secondary);
+  font-size: var(--font-size-compact);
+  text-align: end;
+}

package/dist/ReceiptStrip/ReceiptStrip.d.ts

@@ -0,0 +1,66 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+/** What the strip reports: done, nothing happened, refused or failed, under way, or a caution. */
+export type ReceiptStripTone = 'success' | 'neutral' | 'danger' | 'info' | 'warning';
+export interface ReceiptStripProps extends Omit<HTMLAttributes<HTMLDivElement>, 'role'> {
+    tone?: ReceiptStripTone | undefined;
+    /**
+     * The mark before the words, at 16px. Each tone has one by default (the
+     * check, the info mark, the alert); a strip that says something more
+     * specific passes its own, such as the clock of an expiry or the lock of a
+     * sign-in check.
+     */
+    icon?: ReactNode;
+    /** The outcome, in one or two sentences. */
+    children: ReactNode;
+    /** Controls at the strip's end, such as Try again. */
+    actions?: ReactNode;
+}
+/**
+ * What happened, at the foot of a card: "Created ENG-156 · assigned to Agent
+ * SWE", "You declined this. Nothing changed.".
+ *
+ * IT REPLACES THE CARD'S FOOT rather than sitting inside the card as a box of
+ * its own: the card's hairline above it, the card's own edge around it, a
+ * tint under the words. A card never holds a second bordered box.
+ *
+ * A STATUS, OR AN ALERT. A refusal or a failure (`danger`) is an alert, the
+ * one tone a reader must not miss; every other tone is a polite status.
+ * Colour is never alone: the mark and the words say the outcome.
+ */
+export declare function ReceiptStrip({ tone, icon, children, actions, className, ...rest }: ReceiptStripProps): import("react").JSX.Element;
+export interface RefusalStripLabels {
+    retry: string;
+    dismiss: string;
+}
+export declare const REFUSAL_STRIP_LABELS: RefusalStripLabels;
+/** Where the refusal is drawn: under the control that caused it, or as a card's foot. */
+export type RefusalStripPlacement = 'inline' | 'foot';
+export interface RefusalStripProps extends Omit<HTMLAttributes<HTMLElement>, 'role' | 'children'> {
+    /** The refusal, in the engine's own sentence. Never a model's words. */
+    children: ReactNode;
+    /** A second, quieter line: what the person could do about it. */
+    hint?: ReactNode;
+    /** Offers Try again, for a refusal whose class may succeed on a retry. */
+    onRetry?: (() => void) | undefined;
+    /** Try again is under way. */
+    retrying?: boolean | undefined;
+    /** Offers Dismiss. */
+    onDismiss?: (() => void) | undefined;
+    /** `inline` (the default) under a control; `foot` as a card's foot strip. */
+    placement?: RefusalStripPlacement | undefined;
+    labels?: Partial<RefusalStripLabels> | undefined;
+}
+/**
+ * A refusal, drawn where it happened: the write a control tried, or the
+ * change a card was approved for, refused by the engine.
+ *
+ * ONE DRAWING FOR EVERY REFUSAL. Inline it is the sentence in the danger ink
+ * with its actions beside it, under the control that caused it, wrapping
+ * rather than widening the row; at a card's foot it is the danger
+ * `ReceiptStrip`. The sentence is the caller's (the engine's), so the strip
+ * never words a refusal itself.
+ *
+ * AN ALERT, because a write that did not happen is the one outcome a reader
+ * must hear without looking for it.
+ */
+export declare function RefusalStrip({ children, hint, onRetry, retrying, onDismiss, placement, labels: overrides, className, ...rest }: RefusalStripProps): import("react").JSX.Element;

package/dist/ReceiptStrip/index.d.ts

@@ -0,0 +1,3 @@
+import './ReceiptStrip.css';
+export { REFUSAL_STRIP_LABELS, ReceiptStrip, RefusalStrip } from './ReceiptStrip.js';
+export type { ReceiptStripProps, ReceiptStripTone, RefusalStripLabels, RefusalStripPlacement, RefusalStripProps, } from './ReceiptStrip.js';

package/dist/ReceiptStrip/index.js

@@ -0,0 +1,5 @@
+export { REFUSAL_STRIP_LABELS, ReceiptStrip, RefusalStrip } from '../chunk-XQI2OUV4.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/ReceiptStrip-IIRKRTBG.css

@@ -0,0 +1,93 @@
+/*
+ * A card's foot strip: the card's hairline above it, a tint under the words,
+ * the mark on the first line. The tints are the soft step of the tone under
+ * its ink step, the pairing the palette suite measures; the quiet strip is
+ * the inset ground under the secondary ink.
+ */
+.crewlet-receipt-strip {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: start;
+  gap: var(--spacing-2);
+  padding: var(--spacing-2) var(--spacing-4);
+  border-top: 1px solid var(--color-border-default);
+  font-size: var(--font-size-compact);
+  line-height: var(--font-line-height-normal);
+}
+
+.crewlet-receipt-strip--success {
+  background: var(--color-feedback-success-soft);
+  color: var(--color-feedback-success-ink);
+}
+
+.crewlet-receipt-strip--neutral {
+  background: var(--color-surface-inset);
+  color: var(--color-text-secondary);
+}
+
+.crewlet-receipt-strip--info {
+  background: var(--color-feedback-info-soft);
+  color: var(--color-feedback-info-ink);
+}
+
+.crewlet-receipt-strip--warning {
+  background: var(--color-feedback-warning-soft);
+  color: var(--color-feedback-warning-ink);
+}
+
+.crewlet-receipt-strip--danger {
+  background: var(--color-feedback-danger-soft);
+  color: var(--color-feedback-danger-ink);
+}
+
+/* The 16px mark, centred on the first line of the words beside it. */
+.crewlet-receipt-strip__icon {
+  display: inline-flex;
+  align-items: center;
+  height: calc(var(--font-size-compact) * var(--font-line-height-normal));
+}
+
+.crewlet-receipt-strip__text {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+/* The actions keep the strip's ink, so a ghost button reads as part of it. */
+.crewlet-receipt-strip__actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-1);
+  margin-block: calc(var(--spacing-1) * -1);
+}
+
+.crewlet-receipt-strip__actions .crewlet-btn--ghost {
+  color: inherit;
+}
+
+/*
+ * THE INLINE REFUSAL, under the control that caused it: the sentence in the
+ * danger ink, the hint in the secondary ink, the actions beside them, wrapping
+ * onto a second line rather than widening the row.
+ */
+.crewlet-refusal-strip {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-1) var(--spacing-2);
+  max-width: 40rem;
+  font-size: var(--font-size-compact);
+  color: var(--color-feedback-danger-ink);
+  overflow-wrap: anywhere;
+}
+
+.crewlet-refusal-strip__hint {
+  font-size: var(--font-size-xs);
+  color: var(--color-text-secondary);
+}
+
+.crewlet-refusal-strip--foot .crewlet-refusal-strip__hint {
+  color: inherit;
+}

package/dist/RefusalCard/RefusalCard.d.ts

@@ -0,0 +1,34 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface RefusalCardLabels {
+    /** The Tag in the head. */
+    notPermitted: string;
+    /** The house phrase, always said last. */
+    nothingChanged: string;
+}
+export declare const REFUSAL_CARD_LABELS: RefusalCardLabels;
+export interface RefusalCardProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    /** The action that was asked for, in sentence case: "File a task". */
+    title: string;
+    /** An optional first sentence: "You do not have permission to file tasks." */
+    heading?: ReactNode;
+    /**
+     * Why, in the product's own words: the access the action needs and what the
+     * person holds ("Filing tasks needs Tracker access, and your role includes
+     * Knowledge only."). Assembled from the engine's answer, never a model's.
+     */
+    children: ReactNode;
+    /** Utilities at the foot: "Copy a request to an admin", "About access". Nothing is sent on the person's behalf. */
+    actions?: ReactNode;
+    labels?: Partial<RefusalCardLabels> | undefined;
+}
+/**
+ * A request the person's own access does not allow, said as the product says
+ * it: the action asked for as the title, "Not permitted" as a neutral Tag
+ * with the lock (nothing went wrong, so not the danger tone), the access it
+ * needs and what the person holds, and always "Nothing changed.".
+ *
+ * IT OFFERS NO WORKAROUND. The foot holds only what the person can do with
+ * their own hands (copy a request to send an admin, read about access), and
+ * starts on the card's text edge, because none of it is a decision.
+ */
+export declare function RefusalCard({ title, heading, children, actions, labels: overrides, className, ...rest }: RefusalCardProps): import("react").JSX.Element;

package/dist/RefusalCard/index.d.ts

@@ -0,0 +1,3 @@
+import './RefusalCard.css';
+export { REFUSAL_CARD_LABELS, RefusalCard } from './RefusalCard.js';
+export type { RefusalCardLabels, RefusalCardProps } from './RefusalCard.js';

package/dist/RefusalCard/index.js

@@ -0,0 +1,10 @@
+export { REFUSAL_CARD_LABELS, RefusalCard } from '../chunk-BLPT6GHV.js';
+import '../chunk-WDIVALLP.js';
+import '../chunk-KYIAFNU7.js';
+import '../chunk-WIATRXEJ.js';
+import '../chunk-INHXF2CL.js';
+import '../chunk-AV2DXAEL.js';
+import '../chunk-BHHIIK3M.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/RefusalCard-UM67F5HB.css

@@ -0,0 +1,8 @@
+/* The first sentence carries the weight; "Nothing changed." closes in the secondary ink. */
+.crewlet-refusal-card__heading {
+  font-weight: var(--font-weight-medium);
+}
+
+.crewlet-refusal-card__nothing {
+  color: var(--color-text-secondary);
+}

package/dist/RelativeTime/clock.d.ts

@@ -1,9 +1,3 @@
-/**
- * The shared instant, in epoch ms, re-rendering the caller once a second.
- *
- * Pass the value DOWN rather than calling this again deeper: two components
- * reading their own clock is the disagreement it exists to prevent.
- */
 export declare function useNow(): number;
 /** The current instant without subscribing, for an event handler or an effect. */
 export declare function currentNow(): number;

package/dist/RelativeTime/index.js

@@ -1,4 +1,4 @@
-export { RelativeTime, currentNow, formatElapsed, formatExact, formatRelative, formatUntil, toISO, toInstant, useNow } from '../chunk-3CZ7XAVY.js';
+export { RelativeTime, currentNow, formatElapsed, formatExact, formatRelative, formatUntil, toISO, toInstant, useNow } from '../chunk-KS7YIJ4S.js';
 import '../chunk-EUCC37WY.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/ResizeHandle-2UNSZ4ZQ.css

@@ -0,0 +1,59 @@
+/*
+ * The grip between a panel and the page beside it (`ResizeHandle`).
+ *
+ * DRAWN AS NOTHING AT REST. It stands in a seam that is already drawn (the
+ * frame's inset between two sheets, a panel's hairline), so a handle of its
+ * own would be a second line beside one. It washes in the soft accent under
+ * the pointer, under keyboard focus and for the whole of a drag.
+ *
+ * ITS DRAWN WIDTH IS THE SEAM'S (`--crewlet-resize-handle-width`, the frame's
+ * inset), and its target is the 24px floor whatever that width is: the
+ * hit area reaches half the difference out on each side, so a seam of 8px
+ * is still a target a finger can find.
+ *
+ * Placed by whoever holds it: the shell's aside and a side panel put it on
+ * their own start edge. Absolute, so it takes no room in the layout it sizes.
+ */
+.crewlet-resize-handle {
+  --crewlet-resize-handle-width: var(--size-shell-inset);
+  --crewlet-hit-area-inline: max(0px, calc((var(--size-target-min) - var(--crewlet-resize-handle-width)) / 2));
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  z-index: var(--z-index-raised);
+  width: var(--crewlet-resize-handle-width);
+  border-radius: var(--radius-xs);
+  background: transparent;
+  cursor: col-resize;
+  /* A touch drags the edge rather than scrolling the page under it. */
+  touch-action: none;
+  transition: background var(--motion-duration-fast) var(--motion-easing-default);
+}
+
+/* On a panel's left edge it stands outside the panel, in the seam before it. */
+.crewlet-resize-handle--left {
+  left: calc(var(--crewlet-resize-handle-width) * -1);
+}
+
+.crewlet-resize-handle--right {
+  right: calc(var(--crewlet-resize-handle-width) * -1);
+}
+
+.crewlet-resize-handle:hover,
+.crewlet-resize-handle:focus-visible,
+.crewlet-resize-handle[data-dragging] {
+  background: var(--color-brand-accent-soft);
+}
+
+/* Inside its own box: it draws no edge, and the seam it stands in is the
+   two neighbours' edges, which a ring set outward would run over. */
+.crewlet-resize-handle:focus-visible {
+  outline: 2px solid var(--color-focus);
+  outline-offset: var(--size-focus-ring-inset-offset);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .crewlet-resize-handle {
+    transition: none;
+  }
+}

package/dist/ResultTableCard/ResultTableCard.d.ts

@@ -0,0 +1,64 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import { type TableColumnAlign } from '../Table/index.js';
+/** One download a result offers, fetched on the press: an export the server builds. */
+export interface ResultTableDownload {
+    /** The format, as the button says it: "CSV", "XLSX". */
+    label: string;
+    /** The name the file is offered under: "token-spend-this-week.csv". */
+    filename: string;
+    /** Fetches the file. A rejection reads as a failed download on the button. */
+    file: () => Promise<Blob>;
+}
+export interface ResultTableCardLabels {
+    /** The control that shows every row of a long result: "Show all 48". */
+    showAll: (count: number) => string;
+}
+export declare const RESULT_TABLE_CARD_LABELS: ResultTableCardLabels;
+/** Results with more rows than this show the first `collapsedRows` and "Show all". */
+export declare const RESULT_TABLE_MAX_ROWS = 20;
+/** How many rows a long result shows until the reader asks for all of them. */
+export declare const RESULT_TABLE_COLLAPSED_ROWS = 10;
+export interface ResultTableCardProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    /** What the rows are: "Token spend by agent". Also the table's caption, said and not shown twice. */
+    title: string;
+    /** The window or scope the rows cover, under the title: "This week, from Monday". */
+    window?: ReactNode;
+    headers: ReactNode[];
+    rows: ReactNode[][];
+    /** Each column's edge: `end` for figures. */
+    align?: readonly TableColumnAlign[] | undefined;
+    /** The total row, under the rows it sums. */
+    total?: readonly ReactNode[] | undefined;
+    /** The exports the result offers, each fetched on its press. */
+    downloads?: readonly ResultTableDownload[] | undefined;
+    /**
+     * A way to the page the rows come from ("Open in Spend"), at the foot's
+     * end: the host's own link (a `ButtonLink` ghost small, or its router's).
+     */
+    link?: ReactNode;
+    /** Over this many rows, the card shows `collapsedRows` and "Show all". 20 by default. */
+    maxRows?: number | undefined;
+    /** How many rows a long result shows at first. 10 by default. */
+    collapsedRows?: number | undefined;
+    /** What an empty result says. "No rows match." by default. */
+    emptyMessage?: ReactNode;
+    labels?: Partial<ResultTableCardLabels> | undefined;
+}
+/**
+ * A result as a table in a card: its title and window, the rows with
+ * tabular figures and a total row, and a foot with the exports and a way to
+ * the page the rows come from.
+ *
+ * THE CARD IS THE FRAME. The table draws no edge of its own and its outer
+ * cells take the card's inset, so every row lines up with the title. The
+ * first column takes the room the figures leave and ends a long name in an
+ * ellipsis; a host that cuts names gives the cell its own tooltip.
+ *
+ * A FOOT OF UTILITIES, so it starts on the card's text edge: the downloads
+ * first (their ghost padding pulled out so the first glyph sits on that edge)
+ * and the link at the far end.
+ *
+ * A LONG RESULT IS SHORTENED, never paged: over `maxRows` rows, the first
+ * `collapsedRows` and "Show all 48", which shows the rest in place.
+ */
+export declare function ResultTableCard({ title, window: span, headers, rows, align, total, downloads, link, maxRows, collapsedRows, emptyMessage, labels: overrides, className, ...rest }: ResultTableCardProps): import("react").JSX.Element;

package/dist/ResultTableCard/index.d.ts

@@ -0,0 +1,3 @@
+import './ResultTableCard.css';
+export { RESULT_TABLE_CARD_LABELS, RESULT_TABLE_COLLAPSED_ROWS, RESULT_TABLE_MAX_ROWS, ResultTableCard, } from './ResultTableCard.js';
+export type { ResultTableCardLabels, ResultTableCardProps, ResultTableDownload } from './ResultTableCard.js';

package/dist/ResultTableCard/index.js

@@ -0,0 +1,16 @@
+export { RESULT_TABLE_CARD_LABELS, RESULT_TABLE_COLLAPSED_ROWS, RESULT_TABLE_MAX_ROWS, ResultTableCard } from '../chunk-GZMEWWXW.js';
+import '../chunk-45KMH3E3.js';
+import '../chunk-WDIVALLP.js';
+import '../chunk-HNK43Z3P.js';
+import '../chunk-YNRKVY7X.js';
+import '../chunk-DTIW4CHZ.js';
+import '../chunk-KYIAFNU7.js';
+import '../chunk-WIATRXEJ.js';
+import '../chunk-INHXF2CL.js';
+import '../chunk-AV2DXAEL.js';
+import '../chunk-BHHIIK3M.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';

package/dist/ResultTableCard-HZRUDNTX.css

@@ -0,0 +1,40 @@
+/*
+ * A result in a card. The card, its head and its foot are StatusCard's and
+ * the table is Table's, drawn flush; what a result adds is the column model:
+ * the first column takes the room the figures leave and ends a long name in
+ * an ellipsis, and the figures never wrap.
+ */
+.crewlet-result-table-card__table .crewlet-table__table {
+  table-layout: auto;
+  font-variant-numeric: tabular-nums;
+}
+
+.crewlet-result-table-card__table td:first-child {
+  width: 100%;
+  max-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  overflow-wrap: normal;
+}
+
+.crewlet-result-table-card__table .crewlet-table__cell--end {
+  white-space: nowrap;
+}
+
+/*
+ * THE DOWNLOADS ARE SPANS AROUND A BUTTON (the status region beside each is
+ * a sibling of its button), so the foot's ghost outdent is stated for them
+ * here: the first one's padding and edge are pulled out so its glyph sits on
+ * the card's text edge.
+ */
+.crewlet-result-table-card .crewlet-status-card__actions > .crewlet-result-table-card__download:first-child {
+  margin-inline-start: calc(-1 * (var(--spacing-2) + 1px));
+}
+
+/* The link stands at the foot's far end, its own padding pulled out to the edge. */
+.crewlet-result-table-card__link {
+  display: inline-flex;
+  margin-inline-start: auto;
+  margin-inline-end: calc(-1 * (var(--spacing-2) + 1px));
+}

package/dist/ReviewList/index.js

@@ -1,5 +1,5 @@
-export { ReviewList } from '../chunk-OBUQVGEG.js';
-import '../chunk-IXJHTFXG.js';
+export { ReviewList } from '../chunk-OJ2QULVH.js';
+import '../chunk-3LI4TRUR.js';
 import '../chunk-KYIAFNU7.js';
 import '../chunk-WIATRXEJ.js';
 import '../chunk-PQADV6P6.js';

package/dist/RichEditor/codec.d.ts

@@ -4,7 +4,7 @@
  *
  * # A save with no edit changes nothing, by construction
  *
- * Storage is Markdown, and the bytes are the record: a Knowledge page is
+ * Storage is Markdown, and the bytes are the record: a Doclet page is
  * merged line by line against somebody else's save, and a doc's version is a
  * patch of the lines that moved. An editor that wrote every body back in its
  * own canonical spelling would turn opening a page and pressing Save into a

package/dist/RichEditor/index.js

@@ -1,8 +1,9 @@
-export { RichEditor, preloadRichEditor } from '../chunk-VVOPDWLX.js';
+export { RichEditor, preloadRichEditor } from '../chunk-NI7WUPH3.js';
 export { RICH_EDITOR_LABELS, richEditorLabels } from '../chunk-CSQTDGTS.js';
 import '../chunk-BAKPMH3S.js';
 import '../chunk-BPCY7ZID.js';
 import '../chunk-TEUQWOWZ.js';
-import '../chunk-OG6CL3EB.js';
+import '../chunk-HD4QJ2SI.js';
+import '../chunk-EA23JG6R.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/RichEditor/roundtrip.d.ts

@@ -1,7 +1,7 @@
 /**
  * The editor's Markdown round trip, as plain functions: what a load and a
  * save with no edit write, and the spelling a changed block is written in.
- * An application holds its own bodies to them (a Knowledge page's fixtures, a
+ * An application holds its own bodies to them (a Doclet page's fixtures, a
  * doc's), so a body the editor would rewrite is found by a test rather than
  * by somebody's diff.
  *