@usableapp/cardds 0.7.88 → 0.7.90

package/dist/index.d.ts

@@ -80,6 +80,7 @@ export * from './sticky/StickyDate.js';
 export * from './sticky/StickyField.js';
 export * from './sticky/StickyPick.js';
 export * from './sticky/StickyThread.js';
+export * from './sticky/StickyHeading.js';
 export * from './sticky/StickyBoard.js';
 export * from './sticky/StickyPile.js';
 export * from './sticky/StickyAnswer.js';

package/dist/index.js

@@ -84,6 +84,7 @@ export * from './sticky/StickyDate.js';
 export * from './sticky/StickyField.js';
 export * from './sticky/StickyPick.js';
 export * from './sticky/StickyThread.js';
+export * from './sticky/StickyHeading.js';
 export * from './sticky/StickyBoard.js';
 export * from './sticky/StickyPile.js';
 export * from './sticky/StickyAnswer.js';

package/dist/stamp/Stamp.d.ts

@@ -15,14 +15,21 @@ export interface StampProps extends Omit<ComponentProps<'span'>, 'onClick'> {
     tilt?: 'left' | 'right';
     /** the whole stamp is a button: it renders a `<button>` */
     onClick?: () => void;
+    /** the member presses send and the stamp that already stands in the card's head is STRUCK onto its place by itself (shown large and faint, pressed down to its size) — as it comes on, or as this turns true. Use it when a stamp stands where the layout put it (`Card end`, a centre, the album) and sending should strike it; the stamp does not move and it keeps its `tilt`. A stamp laid ON a surface at a place the member chose is `StampOn arrive`. A stamp without `arrive` is not struck. With `onArrived` */
+    arrive?: boolean;
+    /** an arriving stamp has LANDED (its strike ended; at once where motion is off, and once per arrival) — the app does what follows: sends, closes, sets the card's `leave` */
+    onArrived?: () => void;
 }
 /**
  * Stamp — a perforated paper stamp, 4:5: the pictures fill the inner frame on a tone, the words sit on the picture's foot.
  * Every stamp is ONE size wherever it stands (`--stamp-size`, two taps wide: 96 × 120) — what holds it only places it; a holder narrower than that shows it whole, smaller.
  * The one small stamp is a stamp stuck on something (`StampOn`). Every inner length follows the stamp's width.
  * The outer box holds the size and the shadow; the paper inside is the one whose edge is punched (a mask would cut the shadow too).
+ * With `arrive` the stamp that stands in its place (the head of a card, `end={<Stamp arrive …/>}`) is struck onto it when the member sends, and `onArrived` tells
+ * the app it has landed, so it sends. The strike scales it down from twice its size, so it never moves the layout (it may cover its neighbours for a moment);
+ * a `tilt` is kept, the stamp ends at its turn. Afterwards the same stamp stands in the same place with no strike: drop `arrive` or keep it, nothing is struck twice.
  */
-export declare function Stamp({ pictures, tone, name, words, bare, tilt, onClick, className, ...rest }: StampProps): import("react").JSX.Element;
+export declare function Stamp({ pictures, tone, name, words, bare, tilt, onClick, arrive, onArrived, className, onAnimationEnd, ...rest }: StampProps): import("react").JSX.Element;
 export interface StampPlaceProps extends Omit<ComponentProps<'span'>, 'onClick'> {
     /** a gap nobody is asked to fill: a paler edge (an album's free places) */
     faint?: boolean;

package/dist/stamp/Stamp.js

@@ -1,16 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { cx } from '../cx.js';
 import { pressable } from '../pressable.js';
+import { useStrike } from './useStrike.js';
 /**
  * Stamp — a perforated paper stamp, 4:5: the pictures fill the inner frame on a tone, the words sit on the picture's foot.
  * Every stamp is ONE size wherever it stands (`--stamp-size`, two taps wide: 96 × 120) — what holds it only places it; a holder narrower than that shows it whole, smaller.
  * The one small stamp is a stamp stuck on something (`StampOn`). Every inner length follows the stamp's width.
  * The outer box holds the size and the shadow; the paper inside is the one whose edge is punched (a mask would cut the shadow too).
+ * With `arrive` the stamp that stands in its place (the head of a card, `end={<Stamp arrive …/>}`) is struck onto it when the member sends, and `onArrived` tells
+ * the app it has landed, so it sends. The strike scales it down from twice its size, so it never moves the layout (it may cover its neighbours for a moment);
+ * a `tilt` is kept, the stamp ends at its turn. Afterwards the same stamp stands in the same place with no strike: drop `arrive` or keep it, nothing is struck twice.
  */
-export function Stamp({ pictures, tone = 'custard', name, words, bare, tilt, onClick, className, ...rest }) {
+export function Stamp({ pictures, tone = 'custard', name, words, bare, tilt, onClick, arrive, onArrived, className, onAnimationEnd, ...rest }) {
     const shown = pictures.slice(0, 4);
+    const { struck } = useStrike(arrive, onArrived, onAnimationEnd);
     const { tap, Box, boxProps } = pressable(onClick, 'span', rest);
-    return (_jsx(Box, { className: cx('stamp', `stamp--${shown.length}`, bare && 'stamp--bare', tilt && `stamp--tilt-${tilt}`, tap && 'stamp--tap', className), ...boxProps, children: _jsx("span", { className: "stamp__paper", children: _jsxs("span", { className: cx('stamp__pic', `sticky--${tone}`), children: [shown.map((picture, i) => _jsx("span", { className: "stamp__art", "aria-hidden": "true", children: picture }, i)), (name != null || words != null) && (_jsxs("span", { className: "stamp__cap", children: [words != null && _jsx("span", { className: "stamp__words", children: words }), name != null && _jsx("span", { className: "stamp__name", children: name })] }))] }) }) }));
+    return (_jsx(Box, { className: cx('stamp', `stamp--${shown.length}`, bare && 'stamp--bare', tilt && `stamp--tilt-${tilt}`, tap && 'stamp--tap', arrive && 'stamp--arrive', className), onAnimationEnd: struck, ...boxProps, children: _jsx("span", { className: "stamp__paper", children: _jsxs("span", { className: cx('stamp__pic', `sticky--${tone}`), children: [shown.map((picture, i) => _jsx("span", { className: "stamp__art", "aria-hidden": "true", children: picture }, i)), (name != null || words != null) && (_jsxs("span", { className: "stamp__cap", children: [words != null && _jsx("span", { className: "stamp__words", children: words }), name != null && _jsx("span", { className: "stamp__name", children: name })] }))] }) }) }));
 }
 /**
  * StampPlace — an empty place for a stamp: a 4:5 frame of round dots the size a Stamp is (`--stamp-size`), a word or an Icon inside.

package/dist/stamp/StampOn.d.ts

@@ -24,7 +24,7 @@ export interface StampOnProps extends ComponentProps<'div'> {
     /** the stamp at the stamp's MAIN size, 96 × 120 (`--stamp-size`), to cover what it lies on; the default is the small size, 48 × 60 (`--stamp-sm-size`), which leaves a note's words readable */
     main?: boolean;
     /** the stamp sticks ITSELF: as it comes onto the screen it is struck onto its place (shown large, pressed down to its size). Nobody
-     *  picked it or pressed to stick it — the app shows it when its own move (send) begins. With `onArrived` */
+     *  picked it or pressed to stick it — the app shows it when its own move (send) begins. With `onArrived`. A stamp that already stands in a card's head or a centre, where the layout put it, is `Stamp arrive` instead */
     arrive?: boolean;
     /** an arriving stamp has LANDED (its strike ended; at once where motion is off) — the app does what follows: sends, closes */
     onArrived?: () => void;

package/dist/stamp/StampOn.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useContext, useEffect, useRef, useState } from 'react';
 import { cx } from '../cx.js';
-import { reducedMotion, useControlled } from '../state.js';
+import { useControlled } from '../state.js';
 import { Icon } from '../type/Icon.js';
 import { word } from '../words.js';
 import { UnderNotes } from './underNotes.js';
+import { useStrike } from './useStrike.js';
 const MIDDLE = { x: 0.5, y: 0.5 };
 const STEP = 0.02; // an arrow key's move: a share of the surface
 const MOVES = { ArrowLeft: [-STEP, 0], ArrowRight: [STEP, 0], ArrowUp: [0, -STEP], ArrowDown: [0, STEP] };
@@ -18,7 +19,6 @@ function within(el, x, y) {
     const mx = el.offsetWidth / 2 / box.clientWidth, my = el.offsetHeight / 2 / box.clientHeight;
     return { x: round(clamp(x, mx, 1 - mx)), y: round(clamp(y, my, 1 - my)) };
 }
-const STRIKE = 'strike'; // css/tokens.css — the strike every mark struck onto paper reads
 const write = (el, at) => { el.style.setProperty('--stamp-on-x', String(at.x)); el.style.setProperty('--stamp-on-y', String(at.y)); };
 /**
  * StampOn — a Stamp (the child) stuck on a surface at the place the member chose. The surface is the nearest positioned box:
@@ -46,7 +46,7 @@ export function StampOn({ at, defaultAt = MIDDLE, turn = 0, onAtChange, label, o
     const grip = useRef(null);
     const timer = useRef(undefined);
     const moves = onAtChange != null && !under;
-    const [arrived, setArrived] = useState(false);
+    const { arrived, struck } = useStrike(arrive, onArrived, onAnimationEnd);
     const removes = onRemove != null && !under && !(arrive && !arrived);
     const ask = (next) => { if (next.x !== shown.x || next.y !== shown.y)
         request(next); };
@@ -115,20 +115,6 @@ export function StampOn({ at, defaultAt = MIDDLE, turn = 0, onAtChange, label, o
         if (!moves)
             show();
     };
-    const landed = useRef(onArrived);
-    landed.current = onArrived;
-    const land = () => { setArrived(true); landed.current?.(); };
-    useEffect(() => { if (!arrive)
-        setArrived(false);
-    else if (reducedMotion()) {
-        setArrived(true);
-        landed.current?.();
-    } }, [arrive]); // no strike to wait for
-    const struck = (e) => {
-        onAnimationEnd?.(e);
-        if (arrive && e.target === e.currentTarget && e.animationName === STRIKE)
-            land();
-    };
     const place = { '--stamp-on-x': shown.x, '--stamp-on-y': shown.y, '--stamp-on-turn': turn, ...style };
     const own = moves || removes ? { tabIndex: 0, role: 'group', 'aria-label': label, onKeyDown: key } : null;
     const drag = moves ? { onPointerDown: down, onPointerMove: move, onPointerUp: up, onPointerCancel: up } : null;

package/dist/stamp/useStrike.d.ts

@@ -0,0 +1,7 @@
+import { type AnimationEvent } from 'react';
+/** a holder that `arrive`s: has its strike ended? Returns `arrived` (false again once `arrive` turns off) and `struck`, the holder's `onAnimationEnd`
+ *  (it calls `onAnimationEnd` first). `onArrived` comes once per arrival: when the strike ends, at once where motion is off */
+export declare function useStrike<E extends Element>(arrive: boolean | undefined, onArrived: (() => void) | undefined, onAnimationEnd?: (e: AnimationEvent<E>) => void): {
+    arrived: boolean;
+    struck: (e: AnimationEvent<E>) => void;
+};

package/dist/stamp/useStrike.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from 'react';
+import { reducedMotion, useLatest } from '../state.js';
+const STRIKE = 'strike'; // css/tokens.css — the strike every mark struck onto paper reads
+/** a holder that `arrive`s: has its strike ended? Returns `arrived` (false again once `arrive` turns off) and `struck`, the holder's `onAnimationEnd`
+ *  (it calls `onAnimationEnd` first). `onArrived` comes once per arrival: when the strike ends, at once where motion is off */
+export function useStrike(arrive, onArrived, onAnimationEnd) {
+    const told = useLatest(onArrived);
+    const [arrived, setArrived] = useState(false);
+    const land = () => { setArrived(true); told.current?.(); };
+    useEffect(() => { if (!arrive)
+        setArrived(false);
+    else if (reducedMotion())
+        land(); }, [arrive]); // no strike to wait for
+    const struck = (e) => {
+        onAnimationEnd?.(e);
+        if (arrive && e.target === e.currentTarget && e.animationName === STRIKE)
+            land();
+    };
+    return { arrived, struck };
+}

package/dist/sticky/StickyHeading.d.ts

@@ -0,0 +1,309 @@
+import type { HTMLAttributes, ReactNode, Ref } from 'react';
+export interface StickyHeadingProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    /** the element it renders (React 19 passes `ref` as a prop) */
+    ref?: Ref<HTMLElement>;
+    /** what the notes are about — the subject of the chat, one line; a title too long for the line is cut with an ellipsis */
+    title: ReactNode;
+    /** a short second thing beside it — when ("Tomorrow 6 pm"); it drops to a line of its own where the room is narrow */
+    caption?: ReactNode;
+    /** the element: `span` (default) on a note — a note may be a button, and a button holds no heading; `h2` as the first child of a StickyThread, where it is the heading of that thread */
+    as?: 'span' | 'h2';
+}
+/**
+ * StickyHeading — names what a chat told in notes is about, for as long as that lasts (a job agreed and its time): the subject and a short
+ * caption written on whatever it stands on, a dotted rule under it. One line where there is room (the subject, then the caption), two where there is not.
+ * Information only: nothing to press, no paper of its own.
+ *
+ * It stands in two places, both already there, and the notes have no prop for it:
+ * - ON A NOTE in the list of chats — in that Sticky's `stuck`: across the top of the note, on its paper. The note's words start under it and show two lines at most, so they never run under the foot; the stamps stuck on the note stay visible.
+ * - IN THE ROOM — as the FIRST child of a `StickyThread`: across the thread's top, staying there while the notes run under it, with room before the first note. A `lapped` thread with it leans every note exactly as without it.
+ *
+ * When the subject ends the app stops rendering it, from both places: the notes are exactly as they were.
+ *
+ * What a screen reader hears. In the room, `as="h2"`: "title caption, heading level 2" — the sub-heading of that chat, under the screen's h1 (the TopBar's title: who the chat is with), so it is
+ * found with the headings rotor. On a note, the default `span`: no heading (a button holds none), the words are part of the note's name, read after the note's words and its foot because the layer
+ * that holds things stuck on a note comes after the paper in the page.
+ */
+export declare function StickyHeading({ title, caption, as, className, ...rest }: StickyHeadingProps): import("react").DetailedReactHTMLElement<{
+    /** the element it renders (React 19 passes `ref` as a prop) */
+    ref?: Ref<HTMLElement>;
+    translate?: "yes" | "no" | undefined | undefined;
+    onChange?: import("react").ChangeEventHandler<HTMLElement, Element> | undefined;
+    slot?: string | undefined | undefined;
+    style?: import("react").CSSProperties | undefined;
+    dir?: string | undefined | undefined;
+    children?: ReactNode;
+    suppressHydrationWarning?: boolean | undefined | undefined;
+    color?: string | undefined | undefined;
+    id?: string | undefined | undefined;
+    lang?: string | undefined | undefined;
+    nonce?: string | undefined | undefined;
+    part?: string | undefined | undefined;
+    role?: import("react").AriaRole | undefined;
+    tabIndex?: number | undefined | undefined;
+    "aria-activedescendant"?: string | undefined | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    "aria-braillelabel"?: string | undefined | undefined;
+    "aria-brailleroledescription"?: string | undefined | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-colcount"?: number | undefined | undefined;
+    "aria-colindex"?: number | undefined | undefined;
+    "aria-colindextext"?: string | undefined | undefined;
+    "aria-colspan"?: number | undefined | undefined;
+    "aria-controls"?: string | undefined | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+    "aria-describedby"?: string | undefined | undefined;
+    "aria-description"?: string | undefined | undefined;
+    "aria-details"?: string | undefined | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    "aria-errormessage"?: string | undefined | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+    "aria-keyshortcuts"?: string | undefined | undefined;
+    "aria-label"?: string | undefined | undefined;
+    "aria-labelledby"?: string | undefined | undefined;
+    "aria-level"?: number | undefined | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+    "aria-owns"?: string | undefined | undefined;
+    "aria-placeholder"?: string | undefined | undefined;
+    "aria-posinset"?: number | undefined | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined | undefined;
+    "aria-rowcount"?: number | undefined | undefined;
+    "aria-rowindex"?: number | undefined | undefined;
+    "aria-rowindextext"?: string | undefined | undefined;
+    "aria-rowspan"?: number | undefined | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    "aria-valuemax"?: number | undefined | undefined;
+    "aria-valuemin"?: number | undefined | undefined;
+    "aria-valuenow"?: number | undefined | undefined;
+    "aria-valuetext"?: string | undefined | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined | undefined;
+    onCopy?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    onCopyCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    onCut?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    onCutCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    onPaste?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    onPasteCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    onCompositionEnd?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    onCompositionStart?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    onCompositionUpdate?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLElement> | undefined;
+    onFocusCapture?: import("react").FocusEventHandler<HTMLElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLElement> | undefined;
+    onBlurCapture?: import("react").FocusEventHandler<HTMLElement> | undefined;
+    onChangeCapture?: import("react").ChangeEventHandler<HTMLElement, Element> | undefined;
+    onBeforeInput?: import("react").InputEventHandler<HTMLElement> | undefined;
+    onBeforeInputCapture?: import("react").InputEventHandler<HTMLElement> | undefined;
+    onInput?: import("react").InputEventHandler<HTMLElement> | undefined;
+    onInputCapture?: import("react").InputEventHandler<HTMLElement> | undefined;
+    onReset?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onResetCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSubmit?: import("react").SubmitEventHandler<HTMLElement> | undefined;
+    onSubmitCapture?: import("react").SubmitEventHandler<HTMLElement> | undefined;
+    onInvalid?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onInvalidCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoad?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onError?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onErrorCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    onKeyUp?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    onAbort?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onAbortCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onCanPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onCanPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onCanPlayThrough?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onDurationChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onDurationChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onEmptied?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onEmptiedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onEncrypted?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onEncryptedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onEndedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadedData?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadedDataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadedMetadata?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadStart?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onLoadStartCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onPause?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onPauseCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onPlaying?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onPlayingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onProgress?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onProgressCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onRateChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onRateChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSeeked?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSeekedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSeeking?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSeekingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onStalled?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onStalledCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSuspend?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSuspendCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onTimeUpdate?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onVolumeChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onWaiting?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onWaitingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onAuxClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onAuxClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onContextMenu?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onContextMenuCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onDoubleClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onDoubleClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onDrag?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragEnd?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragEndCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragEnter?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragEnterCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragExit?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragExitCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragLeave?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragLeaveCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragOver?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragOverCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragStart?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDragStartCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDrop?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onDropCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    onMouseDown?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseDownCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseMove?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseMoveCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseOut?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseOutCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseOver?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseOverCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseUp?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onMouseUpCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    onSelect?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onSelectCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    onTouchCancel?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchCancelCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchEnd?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchEndCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchMove?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchMoveCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchStart?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onTouchStartCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    onPointerDown?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerDownCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerMove?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerMoveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerUp?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerUpCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerCancel?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerCancelCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerEnter?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerLeave?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerOver?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerOverCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerOut?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onPointerOutCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onGotPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onLostPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    onScroll?: import("react").UIEventHandler<HTMLElement> | undefined;
+    onScrollCapture?: import("react").UIEventHandler<HTMLElement> | undefined;
+    onScrollEnd?: import("react").UIEventHandler<HTMLElement> | undefined;
+    onScrollEndCapture?: import("react").UIEventHandler<HTMLElement> | undefined;
+    onWheel?: import("react").WheelEventHandler<HTMLElement> | undefined;
+    onWheelCapture?: import("react").WheelEventHandler<HTMLElement> | undefined;
+    onAnimationStart?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    onAnimationEnd?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    onAnimationIteration?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    onToggle?: import("react").ToggleEventHandler<HTMLElement> | undefined;
+    onBeforeToggle?: import("react").ToggleEventHandler<HTMLElement> | undefined;
+    onTransitionCancel?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionCancelCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionEnd?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionRun?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionRunCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionStart?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    onTransitionStartCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    defaultChecked?: boolean | undefined | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined | undefined;
+    accessKey?: string | undefined | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+    autoFocus?: boolean | undefined | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    hidden?: boolean | undefined | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    radioGroup?: string | undefined | undefined;
+    about?: string | undefined | undefined;
+    content?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    prefix?: string | undefined | undefined;
+    property?: string | undefined | undefined;
+    rel?: string | undefined | undefined;
+    resource?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autoCorrect?: string | undefined | undefined;
+    autoSave?: string | undefined | undefined;
+    itemProp?: string | undefined | undefined;
+    itemScope?: boolean | undefined | undefined;
+    itemType?: string | undefined | undefined;
+    itemID?: string | undefined | undefined;
+    itemRef?: string | undefined | undefined;
+    results?: number | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+    popoverTarget?: string | undefined | undefined;
+    inert?: boolean | undefined | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+    className: string;
+}, HTMLElement>;

package/dist/sticky/StickyHeading.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement } from 'react';
+import { cx } from '../cx.js';
+/**
+ * StickyHeading — names what a chat told in notes is about, for as long as that lasts (a job agreed and its time): the subject and a short
+ * caption written on whatever it stands on, a dotted rule under it. One line where there is room (the subject, then the caption), two where there is not.
+ * Information only: nothing to press, no paper of its own.
+ *
+ * It stands in two places, both already there, and the notes have no prop for it:
+ * - ON A NOTE in the list of chats — in that Sticky's `stuck`: across the top of the note, on its paper. The note's words start under it and show two lines at most, so they never run under the foot; the stamps stuck on the note stay visible.
+ * - IN THE ROOM — as the FIRST child of a `StickyThread`: across the thread's top, staying there while the notes run under it, with room before the first note. A `lapped` thread with it leans every note exactly as without it.
+ *
+ * When the subject ends the app stops rendering it, from both places: the notes are exactly as they were.
+ *
+ * What a screen reader hears. In the room, `as="h2"`: "title caption, heading level 2" — the sub-heading of that chat, under the screen's h1 (the TopBar's title: who the chat is with), so it is
+ * found with the headings rotor. On a note, the default `span`: no heading (a button holds none), the words are part of the note's name, read after the note's words and its foot because the layer
+ * that holds things stuck on a note comes after the paper in the page.
+ */
+export function StickyHeading({ title, caption, as = 'span', className, ...rest }) {
+    return createElement(as, { className: cx('sticky-heading', className), ...rest }, _jsx("span", { className: "sticky-heading__title", children: title }), caption != null && _jsx("span", { className: "sticky-heading__caption", children: caption }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usableapp/cardds",
-  "version": "0.7.88",
+  "version": "0.7.90",
   "license": "UNLICENSED",
   "type": "module",
   "description": "card-first mobile design system, React-first: the components in src/ are thin wrappers over the CSS contract (css/*.css stays the only truth); gallery/ shows every story live (npm run dev), tests/ measures the geometry.",