@charcuterie/ui 0.1.1 → 1.0.0

package/dist/Field/FieldGroup.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useUniqueId } from "@charcuterie/logic";
+import { toClassName } from "../toClassName.js";
+/**
+ * A label over **several** controls.
+ *
+ * `Field` mints one id and clones it onto one child, which is the
+ * right shape for a text input and the wrong shape the moment there
+ * are two of them: an `id` can only name one element, and a
+ * `<label htmlFor>` can only point at one. Six of mux-magic's sixteen
+ * field components are in that position — `RegexWithFlagsField`
+ * (pattern, flags, sample, and a checkbox), `NumberWithLookupField`
+ * (three inputs), `LanguageCodeField`, `LanguageCodesField`,
+ * `SubtitleTypesField` (a tag input beside a dropdown) and
+ * `RenameRegexField` (a row per rule) — and every one of them renders
+ * a `FieldLabel` whose `htmlFor` names, at best, one of them.
+ *
+ * ### `<fieldset>` and `<legend>`, not a `<label>`
+ *
+ * This is the one place in the library where `<fieldset>` is right.
+ * `AccordionSection` rejected it for its panel and said why — it is a
+ * *form-control grouping*, and dragging `<legend>` semantics onto
+ * prose is wrong. Here the content **is** a form-control grouping,
+ * so the element means what it says, `<legend>` names the group
+ * natively, and no `role="group"` and no `aria-labelledby` are
+ * needed.
+ *
+ * A `<label>` here would be the mux-magic defect deliberately: a
+ * label pointing at one control, or at none.
+ *
+ * ### What a group cannot carry
+ *
+ * `aria-invalid` has no group form — it belongs on the control that
+ * is actually invalid, and this component does not know which one
+ * that is. So `error` here is *described*, not *asserted*: it joins
+ * `aria-describedby` on the `<fieldset>`, which screen readers read
+ * as focus enters the group. A control inside that is itself invalid
+ * should say so itself, in its own `Field`.
+ *
+ * That is a real limitation and it is stated rather than papered
+ * over — the alternative was to clone `aria-invalid` onto every
+ * child, which marks the valid ones invalid.
+ */
+export const FieldGroup = ({ children, className, description, error, isRequired = false, label, }) => {
+    const baseId = useUniqueId();
+    const descriptionId = `${baseId}-description`;
+    const errorId = `${baseId}-error`;
+    // Description first, error second, for the reason `Field` gives:
+    // a screen reader reads the list in order and the two sentences
+    // are not interchangeable.
+    const describedBy = [
+        description === undefined ? null : descriptionId,
+        error === undefined ? null : errorId,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return (_jsxs("fieldset", { "aria-describedby": describedBy === "" ? undefined : describedBy, className: toClassName(
+        // A `<fieldset>` arrives with a border, an inline margin, a
+        // block padding, and `min-inline-size: min-content` — the
+        // last of which makes it refuse to shrink inside a flex or
+        // grid parent, which is the reason design systems avoid the
+        // element. All four are cleared here, once.
+        "m-0 flex min-w-0 flex-col gap-1.5 border-0 p-0", className), children: [_jsxs("legend", { className: "mb-1.5 p-0 font-medium text-content-primary text-sm", children: [label, isRequired ? (_jsx("span", { "aria-hidden": "true", className: "ms-1 text-intent-danger-content", children: "*" })) : null] }), children, description === undefined ? null : (_jsx("p", { className: "text-content-secondary text-xs", id: descriptionId, children: description })), error === undefined ? null : (_jsx("p", { className: "text-intent-danger-content text-xs", id: errorId, children: error }))] }));
+};
+//# sourceMappingURL=FieldGroup.js.map

package/dist/Field/FieldGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldGroup.js","sourceRoot":"","sources":["../../src/Field/FieldGroup.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGhD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAkB/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,EACzB,QAAQ,EACR,SAAS,EACT,WAAW,EACX,KAAK,EACL,UAAU,GAAG,KAAK,EAClB,KAAK,GACW,EAAa,EAAE;IAC/B,MAAM,MAAM,GAAG,WAAW,EAAE,CAAA;IAE5B,MAAM,aAAa,GAAG,GAAG,MAAM,cAAc,CAAA;IAE7C,MAAM,OAAO,GAAG,GAAG,MAAM,QAAQ,CAAA;IAEjC,iEAAiE;IACjE,gEAAgE;IAChE,2BAA2B;IAC3B,MAAM,WAAW,GAAG;QAClB,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa;QAChD,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO;KACrC;SACE,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,GAAG,CAAC,CAAA;IAEZ,OAAO,CACL,wCAEI,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,EAE9C,SAAS,EAAE,WAAW;QACpB,4DAA4D;QAC5D,0DAA0D;QAC1D,2DAA2D;QAC3D,4DAA4D;QAC5D,4CAA4C;QAC5C,gDAAgD,EAChD,SAAS,CACV,aAED,kBAAQ,SAAS,EAAC,qDAAqD,aACpE,KAAK,EAEL,UAAU,CAAC,CAAC,CAAC,CACZ,8BAIc,MAAM,EAClB,SAAS,EAAC,iCAAiC,kBAGtC,CACR,CAAC,CAAC,CAAC,IAAI,IACD,EAER,QAAQ,EAER,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAClC,YACE,SAAS,EAAC,gCAAgC,EAC1C,EAAE,EAAE,aAAa,YAEhB,WAAW,GACV,CACL,EAEA,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAC5B,YACE,SAAS,EAAC,oCAAoC,EAC9C,EAAE,EAAE,OAAO,YAEV,KAAK,GACJ,CACL,IACQ,CACZ,CAAA;AACH,CAAC,CAAA"}

package/dist/FileDropZone/FileDropZone.d.ts

@@ -0,0 +1,63 @@
+import type { ReactNode } from "react";
+export type FileDropZoneProps = {
+    /** An `accept` list, passed straight to the input. */
+    accept?: string;
+    className?: string;
+    /** Secondary line — the formats taken, a size cap. */
+    description?: ReactNode;
+    isDisabled?: boolean;
+    isMultiple?: boolean;
+    /** The control's accessible name, and its visible prompt. */
+    label: string;
+    onDropFiles: (files: File[]) => void;
+    /**
+     * Dropped text, when there is any. A browser hands over a dragged
+     * link as `text/plain` and no files at all, which is what
+     * gallery-downloader's page is built entirely around — it takes
+     * `dataTransfer.getData("text")` and never looks at `.files`.
+     */
+    onDropText?: (text: string) => void;
+};
+/**
+ * The one drag target in the fleet is gallery-downloader's, and it
+ * gets the hard part right: `dragenter`/`dragleave` fire once per
+ * *element* the pointer crosses, not once per zone, so a naive
+ * implementation flickers over every child — and that page keeps a
+ * `dragDepth` counter, which is the correct fix. It is reproduced
+ * below with credit.
+ *
+ * What it has no answer for is the part that cannot be fixed by
+ * counting:
+ *
+ * ### Dragging is pointer-only, so the zone is a label around an input
+ *
+ * There is **no keyboard gesture for drag-and-drop**. WCAG 2.5.7
+ * (AA since 2.2) requires a single-pointer alternative for any
+ * dragging movement, and the honest one has existed since 1995: a
+ * real `<input type="file">`. So this component is a `<label>`
+ * wrapping a visually-hidden input — the whole zone is the label's
+ * click target, Tab reaches the input, Space and Enter open the
+ * picker, and the drop handlers are an *enhancement* on top of a
+ * control that already works without them.
+ *
+ * That ordering is the entire design. Building the drop zone first
+ * and bolting on a "or browse" link is how the fleet's version ended
+ * up with an `alert()` as its error channel and no keyboard path at
+ * all.
+ *
+ * ### `dragover` must be prevented, and the reason is a footgun
+ *
+ * A browser's default for `dragover` is *reject the drop*. Not
+ * preventing it means `drop` never fires — nothing errors, the
+ * cursor shows a "no entry" sign, and the zone looks like it has a
+ * broken handler when it in fact has no handler running at all.
+ *
+ * ### It reports text as well as files
+ *
+ * Dragging a link gives you `text/plain` and an empty `files` list.
+ * A zone that only reads `.files` silently ignores the single most
+ * common thing a user drags into a downloader, which is why
+ * `onDropText` is here rather than being someone's follow-up.
+ */
+export declare const FileDropZone: ({ accept, className, description, isDisabled, isMultiple, label, onDropFiles, onDropText, }: FileDropZoneProps) => ReactNode;
+//# sourceMappingURL=FileDropZone.d.ts.map

package/dist/FileDropZone/FileDropZone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileDropZone.d.ts","sourceRoot":"","sources":["../../src/FileDropZone/FileDropZone.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAa,SAAS,EAAE,MAAM,OAAO,CAAA;AAKjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,sDAAsD;IACtD,WAAW,CAAC,EAAE,SAAS,CAAA;IACvB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,CAAA;IACpC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CACpC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,YAAY,GAAI,6FAS1B,iBAAiB,KAAG,SA6JtB,CAAA"}

package/dist/FileDropZone/FileDropZone.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useUniqueId } from "@charcuterie/logic";
+import { useRef, useState } from "react";
+import { toClassName } from "../toClassName.js";
+/**
+ * The one drag target in the fleet is gallery-downloader's, and it
+ * gets the hard part right: `dragenter`/`dragleave` fire once per
+ * *element* the pointer crosses, not once per zone, so a naive
+ * implementation flickers over every child — and that page keeps a
+ * `dragDepth` counter, which is the correct fix. It is reproduced
+ * below with credit.
+ *
+ * What it has no answer for is the part that cannot be fixed by
+ * counting:
+ *
+ * ### Dragging is pointer-only, so the zone is a label around an input
+ *
+ * There is **no keyboard gesture for drag-and-drop**. WCAG 2.5.7
+ * (AA since 2.2) requires a single-pointer alternative for any
+ * dragging movement, and the honest one has existed since 1995: a
+ * real `<input type="file">`. So this component is a `<label>`
+ * wrapping a visually-hidden input — the whole zone is the label's
+ * click target, Tab reaches the input, Space and Enter open the
+ * picker, and the drop handlers are an *enhancement* on top of a
+ * control that already works without them.
+ *
+ * That ordering is the entire design. Building the drop zone first
+ * and bolting on a "or browse" link is how the fleet's version ended
+ * up with an `alert()` as its error channel and no keyboard path at
+ * all.
+ *
+ * ### `dragover` must be prevented, and the reason is a footgun
+ *
+ * A browser's default for `dragover` is *reject the drop*. Not
+ * preventing it means `drop` never fires — nothing errors, the
+ * cursor shows a "no entry" sign, and the zone looks like it has a
+ * broken handler when it in fact has no handler running at all.
+ *
+ * ### It reports text as well as files
+ *
+ * Dragging a link gives you `text/plain` and an empty `files` list.
+ * A zone that only reads `.files` silently ignores the single most
+ * common thing a user drags into a downloader, which is why
+ * `onDropText` is here rather than being someone's follow-up.
+ */
+export const FileDropZone = ({ accept, className, description, isDisabled = false, isMultiple = false, label, onDropFiles, onDropText, }) => {
+    const baseId = useUniqueId();
+    const inputId = `${baseId}-input`;
+    const labelId = `${baseId}-label`;
+    const descriptionId = `${baseId}-description`;
+    const [isDragActive, setIsDragActive] = useState(false);
+    /**
+     * The counter gallery-downloader's page already keeps, and the
+     * reason it has to exist: `dragenter` fires again for every child
+     * element the pointer crosses, and `dragleave` fires for the one
+     * it left — so a plain boolean turns off halfway across the zone
+     * and the highlight strobes.
+     *
+     * A ref rather than state: nothing renders from the depth itself,
+     * only from whether it is above zero, and a re-render per crossed
+     * child during a drag is exactly the jank this is avoiding.
+     */
+    const dragDepth = useRef(0);
+    const endDrag = () => {
+        dragDepth.current = 0;
+        setIsDragActive(false);
+    };
+    const handleDrop = (dropEvent) => {
+        dropEvent.preventDefault();
+        endDrag();
+        if (isDisabled) {
+            return;
+        }
+        const files = Array.from(dropEvent.dataTransfer.files);
+        if (files.length > 0) {
+            onDropFiles(isMultiple ? files : files.slice(0, 1));
+            return;
+        }
+        const text = dropEvent.dataTransfer.getData("text");
+        if (text !== "") {
+            onDropText?.(text);
+        }
+    };
+    return (_jsxs("label", { className: toClassName("flex cursor-pointer flex-col items-center gap-1 rounded-md border-2 border-border-default border-dashed p-6 text-center transition-colors duration-(--duration-fast) ease-standard", isDragActive
+            ? "border-intent-accent-border bg-intent-accent-surface"
+            : "bg-surface-sunken hover:border-border-strong", isDisabled &&
+            "cursor-not-allowed border-border-subtle text-content-disabled hover:border-border-subtle", 
+        // The ring is on the label, driven by the input inside it —
+        // the input is what actually takes focus, and it is
+        // visually hidden, so a ring on the input paints nothing.
+        "focus-within:outline-solid focus-within:outline-(length:--focus-ring-width) focus-within:outline-offset-(--focus-ring-offset) focus-within:outline-focus-ring", className), htmlFor: inputId, onDragEnter: (dragEvent) => {
+            dragEvent.preventDefault();
+            dragDepth.current += 1;
+            if (dragDepth.current === 1) {
+                setIsDragActive(true);
+            }
+        }, onDragLeave: (dragEvent) => {
+            dragEvent.preventDefault();
+            dragDepth.current -= 1;
+            if (dragDepth.current === 0) {
+                setIsDragActive(false);
+            }
+        }, onDragOver: (dragEvent) => {
+            // Not optional. The default action for `dragover` is to
+            // reject the drop, so without this `onDrop` below never runs
+            // and the zone looks broken rather than unhandled.
+            dragEvent.preventDefault();
+        }, onDrop: handleDrop, children: [_jsx("input", { accept: accept, "aria-describedby": description === undefined
+                    ? undefined
+                    : descriptionId, "aria-labelledby": labelId, className: "sr-only", disabled: isDisabled, id: inputId, multiple: isMultiple, onChange: (changeEvent) => {
+                    const files = Array.from(changeEvent.currentTarget.files ?? []);
+                    if (files.length > 0) {
+                        onDropFiles(files);
+                    }
+                    // Cleared so choosing the *same* file twice fires again.
+                    // A file input keeps its value, so the second pick is not
+                    // a change and the handler never runs — which reads as
+                    // "it ignored me" and is the oldest bug in this control.
+                    changeEvent.currentTarget.value = "";
+                }, type: "file" }), _jsx("span", { className: "font-medium text-content-primary text-sm", id: labelId, children: label }), description === undefined ? null : (_jsx("span", { className: "text-content-secondary text-xs", id: descriptionId, children: description }))] }));
+};
+//# sourceMappingURL=FileDropZone.js.map

package/dist/FileDropZone/FileDropZone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileDropZone.js","sourceRoot":"","sources":["../../src/FileDropZone/FileDropZone.tsx"],"names":[],"mappings":"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"}

package/dist/LogViewer/LogViewer.d.ts

@@ -0,0 +1,90 @@
+import type { IntentName } from "@charcuterie/tokens";
+import type { ReactNode } from "react";
+export type LogLine = {
+    intent?: IntentName;
+    key: string;
+    text: string;
+};
+export type LogViewerProps = {
+    className?: string;
+    /**
+     * Announce new lines to a screen reader. **Off by default**, and
+     * that is a considered choice rather than an oversight — see
+     * below.
+     */
+    isAnnounced?: boolean;
+    /** The pane's accessible name. Required. */
+    label: string;
+    lines: LogLine[];
+    /**
+     * Oldest lines past this are dropped from the DOM. A rip in
+     * progress emits a line every few hundred milliseconds for an
+     * hour, and the browser keeps every node.
+     */
+    maxLines?: number;
+};
+/**
+ * Three repos render a scrolling log pane —
+ * mux-magic's `JobLogsDisclosure` and `StepLogs`, rip-deck's
+ * `LogModal` — and between them they have four defects that this
+ * component exists to not have. A fifth, below the effects, is not
+ * theirs: it is defect 1 coming back through the front door, in this
+ * component, found by the first app to consume it.
+ *
+ * ### 1. The one that follows nothing
+ *
+ * ```tsx
+ * useEffect(() => {
+ *   const pane = paneRef.current
+ *   if (pane) pane.scrollTop = pane.scrollHeight
+ * }, [])          // ← empty deps
+ * ```
+ *
+ * That is mux-magic's auto-scroll, and it runs **once**, on mount,
+ * when the pane is empty and `scrollHeight` is `clientHeight`. Every
+ * line after it arrives below the fold. It reads as correct, it is
+ * the shape everyone writes, and the log simply never follows.
+ *
+ * ### 2. Following that cannot be escaped
+ *
+ * The naive fix — scroll to the bottom on every render — is worse:
+ * a user scrolling back to read the line that mentioned an error is
+ * yanked to the end twice a second. Following has to be *pinned to
+ * the user's own position*, which is what `isFollowing` below is: it
+ * turns off the moment the user scrolls away and back on when they
+ * return to the bottom, and there is a button for when they do not
+ * want to scroll all that way.
+ *
+ * ### 3. `data-log-id`
+ *
+ * mux-magic's pane carries one. It is a `data-testid` under a
+ * different name — a handle only the test suite can see — and this
+ * package's `sourceRules.test.ts` bans the practice rather than the
+ * spelling. The pane here is found by its `label`, the same query
+ * Playwright makes.
+ *
+ * ### 4. Announcing an hour of build output
+ *
+ * `role="log"` is the correct role and `aria-live` is off unless
+ * asked for. A live log pane emitting a line every 300 ms is a
+ * screen reader that cannot be interrupted and a user who cannot
+ * read anything else on the page — the accessible answer for a
+ * long-running job is a `LiveStatusIndicator` announcing *state*
+ * and a log that is there to be read when wanted. `isAnnounced`
+ * exists for the short case: a five-line result panel where the
+ * lines *are* the outcome.
+ *
+ * ### Not every boolean is a state kind
+ *
+ * `isFollowing` is `useState`, not `useVisibility`, and this is the
+ * first component in the library to say so out loud. The kinds in
+ * `@charcuterie/logic` earn their keep when state is **registered**
+ * (members join a group), **composed** (focus and selection
+ * disagreeing), or **shared** (a trigger and a panel at opposite
+ * ends of a tree). None of that is true here: one component reads
+ * one boolean it wrote itself. Reaching for `useVisibility` because
+ * it is also a boolean would make `isVisible` mean "is following",
+ * which is how a state layer stops meaning anything.
+ */
+export declare const LogViewer: ({ className, isAnnounced, label, lines, maxLines, }: LogViewerProps) => ReactNode;
+//# sourceMappingURL=LogViewer.d.ts.map

package/dist/LogViewer/LogViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogViewer.d.ts","sourceRoot":"","sources":["../../src/LogViewer/LogViewer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAOtC,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,SAAS,GAAI,qDAMvB,cAAc,KAAG,SA8JnB,CAAA"}

package/dist/LogViewer/LogViewer.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Button } from "../Button/Button.js";
+import { INTENT_CONTENT_CLASS } from "../intentStyles.js";
+import { toClassName } from "../toClassName.js";
+/**
+ * Three repos render a scrolling log pane —
+ * mux-magic's `JobLogsDisclosure` and `StepLogs`, rip-deck's
+ * `LogModal` — and between them they have four defects that this
+ * component exists to not have. A fifth, below the effects, is not
+ * theirs: it is defect 1 coming back through the front door, in this
+ * component, found by the first app to consume it.
+ *
+ * ### 1. The one that follows nothing
+ *
+ * ```tsx
+ * useEffect(() => {
+ *   const pane = paneRef.current
+ *   if (pane) pane.scrollTop = pane.scrollHeight
+ * }, [])          // ← empty deps
+ * ```
+ *
+ * That is mux-magic's auto-scroll, and it runs **once**, on mount,
+ * when the pane is empty and `scrollHeight` is `clientHeight`. Every
+ * line after it arrives below the fold. It reads as correct, it is
+ * the shape everyone writes, and the log simply never follows.
+ *
+ * ### 2. Following that cannot be escaped
+ *
+ * The naive fix — scroll to the bottom on every render — is worse:
+ * a user scrolling back to read the line that mentioned an error is
+ * yanked to the end twice a second. Following has to be *pinned to
+ * the user's own position*, which is what `isFollowing` below is: it
+ * turns off the moment the user scrolls away and back on when they
+ * return to the bottom, and there is a button for when they do not
+ * want to scroll all that way.
+ *
+ * ### 3. `data-log-id`
+ *
+ * mux-magic's pane carries one. It is a `data-testid` under a
+ * different name — a handle only the test suite can see — and this
+ * package's `sourceRules.test.ts` bans the practice rather than the
+ * spelling. The pane here is found by its `label`, the same query
+ * Playwright makes.
+ *
+ * ### 4. Announcing an hour of build output
+ *
+ * `role="log"` is the correct role and `aria-live` is off unless
+ * asked for. A live log pane emitting a line every 300 ms is a
+ * screen reader that cannot be interrupted and a user who cannot
+ * read anything else on the page — the accessible answer for a
+ * long-running job is a `LiveStatusIndicator` announcing *state*
+ * and a log that is there to be read when wanted. `isAnnounced`
+ * exists for the short case: a five-line result panel where the
+ * lines *are* the outcome.
+ *
+ * ### Not every boolean is a state kind
+ *
+ * `isFollowing` is `useState`, not `useVisibility`, and this is the
+ * first component in the library to say so out loud. The kinds in
+ * `@charcuterie/logic` earn their keep when state is **registered**
+ * (members join a group), **composed** (focus and selection
+ * disagreeing), or **shared** (a trigger and a panel at opposite
+ * ends of a tree). None of that is true here: one component reads
+ * one boolean it wrote itself. Reaching for `useVisibility` because
+ * it is also a boolean would make `isVisible` mean "is following",
+ * which is how a state layer stops meaning anything.
+ */
+export const LogViewer = ({ className, isAnnounced = false, label, lines, maxLines = 500, }) => {
+    const paneRef = useRef(null);
+    const [isFollowing, setIsFollowing] = useState(true);
+    const shownLines = lines.length > maxLines
+        ? lines.slice(lines.length - maxLines)
+        : lines;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `shownLines` is read through the DOM, not through the closure — `pane.scrollHeight` is a *consequence* of the lines having rendered, so the linter sees a dependency it cannot trace and calls it unnecessary. Removing it is not a style change: the effect then runs only when `isFollowing` flips, which is mux-magic's `}, [])` bug rebuilt exactly. `yarn lint` runs `--write --unsafe`, so this was applied silently once already and the log stopped following.
+    useEffect(() => {
+        const pane = paneRef.current;
+        if (!pane || !isFollowing) {
+            return;
+        }
+        pane.scrollTop = pane.scrollHeight;
+        // `shownLines` rather than an empty array — this is the whole fix
+        // for defect 1, and the dependency *is* the fix.
+    }, [isFollowing, shownLines]);
+    /**
+     * Defect 1 again, and the effect above cannot see it: **a pane can
+     * be measured before it has a box.**
+     *
+     * `AccordionSection` renders its panel with `hidden` rather than
+     * unmounting it, deliberately — "a panel that unmounts loses a
+     * scroll position, a partially typed form, and any subscription its
+     * content opened — and the fleet's log panes are exactly that." A
+     * `hidden` subtree has no layout, so the effect above runs on mount
+     * with `scrollHeight 0` and writes `scrollTop = 0`, and then never
+     * runs again: neither `isFollowing` nor `shownLines` changes when
+     * the section is opened. Measured in mux-magic on a 60-line pane:
+     *
+     * ```
+     * while collapsed : scrollTop 0   scrollHeight 0     clientHeight 0
+     * after expanding : scrollTop 0   scrollHeight 976   clientHeight 254
+     * ```
+     *
+     * That is this component's own `}, [])` bug, rebuilt out of two
+     * components whose individual decisions are both right, and
+     * invisible to both of their test suites — `LogViewer`'s mounted
+     * visible, `Accordion`'s holding content that never measures
+     * itself. mux-magic hit it in its first week as a consumer and
+     * worked around it downstream, in a `DisclosedLogViewer` that
+     * withheld the pane until the section had been opened once. This is
+     * that workaround coming into the library so it can be deleted.
+     *
+     * ### Why the box and not the viewport
+     *
+     * An `IntersectionObserver` answers "is it on screen", which is a
+     * different question with two wrong answers here: a pane below the
+     * fold on a long page is *not* intersecting and has perfectly good
+     * layout, and scrolling the page later would re-fire for no reason.
+     * `ResizeObserver` answers "does it have a box, and is that box
+     * still the same size" — which is the precondition the measurement
+     * above actually needs. Per spec it does not fire at `observe()`
+     * time for an element that is not being rendered, so gaining a box
+     * *is* the first callback, and that is the reveal.
+     *
+     * It pays for itself twice: a window resize re-wraps the lines and
+     * changes what is at the bottom, and a following pane should be at
+     * the new bottom rather than a few lines above it.
+     *
+     * Only while following. A user who scrolled up to read an error is
+     * not dragged back by resizing their window.
+     */
+    useEffect(() => {
+        const pane = paneRef.current;
+        if (!pane || !isFollowing) {
+            return;
+        }
+        const observer = new ResizeObserver(() => {
+            pane.scrollTop = pane.scrollHeight;
+        });
+        observer.observe(pane);
+        return () => {
+            observer.disconnect();
+        };
+    }, [isFollowing]);
+    return (_jsxs("div", { className: toClassName("relative flex flex-col", className), children: [_jsx("div", { "aria-label": label, "aria-live": isAnnounced ? "polite" : "off", className: "max-h-64 overflow-y-auto rounded-md border border-border-subtle bg-surface-sunken p-2 font-mono text-content-secondary text-xs", onScroll: (scrollEvent) => {
+                    const pane = scrollEvent.currentTarget;
+                    // A few pixels of slack, because a fractional device pixel
+                    // ratio means `scrollTop + clientHeight` never lands
+                    // exactly on `scrollHeight` — an equality test here
+                    // un-pins the pane on a 125% display and on nothing else,
+                    // which is the kind of bug that gets reported as "it works
+                    // on my machine".
+                    const isPinnedToBottom = pane.scrollHeight -
+                        pane.scrollTop -
+                        pane.clientHeight <
+                        4;
+                    setIsFollowing(isPinnedToBottom);
+                }, ref: paneRef, role: "log", 
+                // biome-ignore lint/a11y/noNoninteractiveTabindex: a scroll container must be focusable or a keyboard user can see the pane and cannot scroll it — axe's `scrollable-region-focusable`, which fails this component without the line. Chrome started doing it automatically in 2024; Firefox and Safari have not. The rule is right about `<div>`s in general and wrong about scrollers.
+                tabIndex: 0, children: shownLines.length === 0 ? (_jsx("p", { className: "text-content-muted", children: "Waiting for output\u2026" })) : (shownLines.map((line) => (_jsx("p", { className: toClassName("whitespace-pre-wrap break-all", line.intent === undefined
+                        ? null
+                        : INTENT_CONTENT_CLASS[line.intent]), children: line.text }, line.key)))) }), isFollowing ? null : (_jsx(Button, { appearance: "soft", className: "absolute inset-x-0 bottom-2 mx-auto w-fit", intent: "neutral", onClick: () => {
+                    setIsFollowing(true);
+                }, size: "sm", children: "Jump to latest" }))] }));
+};
+//# sourceMappingURL=LogViewer.js.map

package/dist/LogViewer/LogViewer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogViewer.js","sourceRoot":"","sources":["../../src/LogViewer/LogViewer.tsx"],"names":[],"mappings":"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"}

package/dist/Menu/Menu.d.ts

@@ -0,0 +1,81 @@
+import type { Placement } from "@floating-ui/react";
+import type { ReactElement, ReactNode } from "react";
+export type MenuItem = {
+    icon?: ReactNode;
+    isDisabled?: boolean;
+    key: string;
+    label: ReactNode;
+    onSelect: () => void;
+};
+export type MenuProps = {
+    className?: string;
+    isVisible: boolean;
+    items: MenuItem[];
+    /** Outside press, Escape, and choosing an item all land here. */
+    onDismiss: () => void;
+    placement?: Placement;
+    /** The control the menu hangs off. **Cloned, not wrapped.** */
+    trigger: ReactElement;
+};
+/**
+ * A menu is **not** a listbox, and mux-magic's `TypePicker` is the
+ * fleet's one attempt at telling them apart — it renders
+ * `role="menu"` over items that set a value, which is a listbox
+ * wearing the wrong role. The distinction is what the items *are*:
+ *
+ *  - `menuitem` **does** something. Rename, Delete, Copy path.
+ *  - `option` **is** something. It is a value you are choosing.
+ *
+ * A screen reader announces "menu, 4 items" for one and "listbox,
+ * selected, 2 of 4" for the other, and an agent driving the app
+ * needs the second to know what state it left behind. Getting it
+ * wrong is invisible in a browser and invisible to axe.
+ *
+ * ### There is no `label` prop, and that corrects a lesson
+ *
+ * `Spinner` (M3), `Popover` and `Modal` (M4) all take a **required**
+ * name, because a `role="status"` and a `role="dialog"` take none
+ * from their content. The obvious move here was a `label` prop doing
+ * the same job, and it was written that way first — then measured
+ * as doing nothing.
+ *
+ * `useRole(context, { role: "menu" })` puts **`aria-labelledby` on
+ * the panel pointing at the trigger**, and `aria-labelledby` beats
+ * `aria-label`. So the menu was already named — "Bay 3", from the
+ * button — and the prop was silently discarded. That is also the ARIA
+ * Authoring Practices menu-button pattern, where a menu is named by
+ * the control that opens it.
+ *
+ * The rule the other three teach is therefore narrower than it
+ * looked: **an overlay with no trigger relationship needs its own
+ * name.** A menu has one, so the requirement moves to the trigger —
+ * which `Button` and `IconButton` already enforce.
+ *
+ * ### Roving focus, and the composition `Tabs` already proved
+ *
+ * `RovingFocus` alone this time — there is no selection, because a
+ * menu item is not selected, it is invoked. That is the same
+ * two-kinds argument from the other side: `Tabs` needed both kinds
+ * because a tab is chosen *and* focused, and a menu needs one
+ * because a menu item is only ever focused.
+ *
+ * ### Focus moves in, once, and only on opening
+ *
+ * A menu is one of the few patterns where focus must jump on open —
+ * otherwise the keyboard user who pressed Enter on the trigger is
+ * still on the trigger with a menu they cannot reach. It happens in
+ * the panel's own effect rather than through
+ * `FloatingFocusManager`'s `initialFocus`, because the element to
+ * focus is whichever one `RovingFocus` says is active, and that is
+ * not known until the items have registered.
+ *
+ * ### No type-ahead, deliberately
+ *
+ * The APG lists type-ahead as optional for a menu and required for a
+ * listbox, and none of the fleet's menus are long enough to need it
+ * — the largest has six items. Adding it would mean a keystroke
+ * buffer and a timer in a component that currently has neither, for
+ * a menu you can cross in three arrow presses.
+ */
+export declare const Menu: ({ className, isVisible, items, onDismiss, placement, trigger, }: MenuProps) => ReactNode;
+//# sourceMappingURL=Menu.d.ts.map

package/dist/Menu/Menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Menu.d.ts","sourceRoot":"","sources":["../../src/Menu/Menu.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAYnD,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAMpD,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,iEAAiE;IACjE,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,+DAA+D;IAC/D,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,IAAI,GAAI,iEAOlB,SAAS,KAAG,SA8Ld,CAAA"}