@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/operation-icons.js

@@ -2,9 +2,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { BrainIcon, CalendarClockIcon, CompassIcon, FileTextIcon, ListTodoIcon, MessageCircleQuestionIcon, SearchIcon, SquareTerminalIcon, UsersIcon, WrenchIcon, } from "lucide-react";
 import { cx } from "./primitives/cx.js";
-// One glyph per resolved vocabulary member — operational meaning, never
-// a brand or a tool name (the presenter already resolved unknown tokens
-// to "generic", so this record is total over what can reach it).
 const OPERATION_GLYPHS = {
     search: SearchIcon,
     file: FileTextIcon,
@@ -13,68 +10,31 @@ const OPERATION_GLYPHS = {
     memory: BrainIcon,
     delegation: UsersIcon,
     routine: CalendarClockIcon,
-    // The plan-progress member (contract §8's recorded conditional):
-    // a checklist, unmistakably not the generic wrench.
     todo: ListTodoIcon,
     navigation: CompassIcon,
     generic: WrenchIcon,
 };
-// The state language, keyed by protocol state alone — the words assistive
-// tech hears where sighted readers get ink and the headline ladder.
 const STATE_WORDS = {
     "input-streaming": "Queued",
     "input-available": "Running",
     "output-available": "Completed",
     "output-error": "Failed",
-    // Its own quiet word: a member declined the approval — not interrupted
-    // (nobody cut it), not failed (nothing broke), and not the door's
-    // "Declined" (TVC-038 — the tool never got to answer).
     denied: "Not approved",
     cancelled: "Interrupted",
-    // Its own quiet word: the tool answered and declined — not
-    // interrupted (nothing cut it), not failed (nothing broke).
     refused: "Declined",
-    // Shares cancelled's outcome word — both landed short of an outcome
-    // through no fault of the tool; the headline frames tell them apart.
     superseded: "Interrupted",
 };
-/** The mark's package-owned chrome — identity, state attribute, ink
- *  rules and the assistive state word — around any glyph. Shared by the
- *  package mark below and the tool-view icon slot, so a registered icon
- *  can replace the GLYPH and nothing else (tool-views.md: one
- *  registration, two roles; the mark's state semantics are never the
- *  adapter's to lose). */
 export function OperationMarkFrame({ status, children, }) {
-    return (_jsxs("span", { "data-tf-op-mark": "", "data-tf-op-state": status, className: cx("tf:grid tf:size-4 tf:shrink-0 tf:place-items-center", 
-        // Queued (a pending call on a run that is not streaming) dims —
-        // the mark stays semantic, never a dashed mystery circle.
-        status === "input-streaming" && "tf:opacity-45", 
-        // The one loud pixel (the visual spec's Status-Only Color Rule):
-        // failure wears destructive ink; cancellation, refusal and a
-        // member's denial stay neutral.
-        status === "output-error" && "tf:text-tf-destructive"), children: [children, _jsx("span", { className: "tf:sr-only", children: STATE_WORDS[status] })] }));
+    return (_jsxs("span", { "data-tf-op-mark": "", "data-tf-op-state": status, className: cx("tf:grid tf:size-4 tf:shrink-0 tf:place-items-center", status === "input-streaming" && "tf:opacity-45", status === "output-error" && "tf:text-tf-destructive"), children: [children, _jsx("span", { className: "tf:sr-only", children: STATE_WORDS[status] })] }));
 }
-/** The process row's leading mark: semantic identity with local state.
- *  Rendered as the row summary's FIRST child — that position is contract
- *  (TVC-050 measures the icon column on it). */
 export function OperationMark({ icon, status, }) {
     const Glyph = OPERATION_GLYPHS[icon];
     return (_jsx(OperationMarkFrame, { status: status, children: _jsx(Glyph, { "aria-hidden": true, className: "tf:size-4" }) }));
 }
-/** The bare semantic glyph, for consent frames: the decision card's title
- *  carries the words and the frame carries the state, so the glyph arrives
- *  silent — no state word, no ink rule, aria-hidden. Same
- *  one-glyph-per-member table as the operation mark, never a fork. */
 export function OperationGlyph({ icon, className, }) {
     const Glyph = OPERATION_GLYPHS[icon];
     return _jsx(Glyph, { "aria-hidden": true, className: cx("tf:size-4", className) });
 }
-/** The inline state pill (Layer A's state badge): a small textual badge
- *  on the affected row for the states that must never read as quiet —
- *  failure, interruption, awaiting input. Mechanical state words only
- *  (the headline ladder owns authored copy); text is the signal, colour
- *  merely underlines it. */
 export function StatePill({ children, destructive = false, }) {
     return (_jsx("span", { "data-tf-state-pill": "", className: cx("tf:shrink-0 tf:rounded-full tf:border tf:border-tf-border tf:px-1.5 tf:py-px tf:text-xs tf:leading-4 tf:whitespace-nowrap", destructive && "tf:text-tf-destructive"), children: children }));
 }
-//# sourceMappingURL=operation-icons.js.map

package/dist/components/pretty-print.d.ts

@@ -1,2 +1 @@
 export declare function prettyPrintParameters(parameters: unknown): string;
-//# sourceMappingURL=pretty-print.d.ts.map

package/dist/components/pretty-print.js

@@ -7,4 +7,3 @@ export function prettyPrintParameters(parameters) {
     }
     return JSON.stringify(parameters, null, 2);
 }
-//# sourceMappingURL=pretty-print.js.map

package/dist/components/primitives/autofocus.d.ts

@@ -1,6 +1 @@
-/** Focuses the surface's marked autofocus target, with one frame of
- * grace for content that mounts a beat after the surface is shown. The
- * predicate guards the deferred attempt: a surface that closed inside
- * that frame must not have focus pulled into it. */
 export declare function focusAutofocusTarget(surface: HTMLElement, stillShowing: () => boolean): void;
-//# sourceMappingURL=autofocus.d.ts.map

package/dist/components/primitives/autofocus.js

@@ -1,13 +1,3 @@
-// The package's opt-in initial-focus convention, shared by every surface
-// that moves focus on open: content marks its own landing spot with
-// data-tf-autofocus (the composer does), and the surface honors it. What
-// happens without a mark is the surface's own affair — the modal dialog
-// falls back to the native first-focusable, the non-modal panel
-// deliberately moves nothing.
-/** Focuses the surface's marked autofocus target, with one frame of
- * grace for content that mounts a beat after the surface is shown. The
- * predicate guards the deferred attempt: a surface that closed inside
- * that frame must not have focus pulled into it. */
 export function focusAutofocusTarget(surface, stillShowing) {
     const target = surface.querySelector("[data-tf-autofocus]");
     if (target !== null) {
@@ -20,4 +10,3 @@ export function focusAutofocusTarget(surface, stillShowing) {
         }
     });
 }
-//# sourceMappingURL=autofocus.js.map

package/dist/components/primitives/button.d.ts

@@ -1,5 +1,5 @@
 import type { AnchorHTMLAttributes, ButtonHTMLAttributes } from "react";
-type TfButtonVariant = "primary" | "ghost" | "send" | "stop" | "icon" | "iconFloating" | "row" | "rowAction" | "rowTouch" | "rowActionTouch" | "prompt" | "bare" | "chip" | "chipQuiet" | "outline" | "answerRow";
+export type TfButtonVariant = "primary" | "ghost" | "send" | "stop" | "icon" | "iconFloating" | "row" | "rowAction" | "rowTouch" | "rowActionTouch" | "prompt" | "bare" | "chip" | "chipQuiet" | "outline" | "answerRow";
 interface TfButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     variant?: TfButtonVariant;
 }
@@ -8,4 +8,3 @@ export declare function TfLinkButton({ variant, className, children, ...props }:
     variant?: TfButtonVariant;
 }): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=button.d.ts.map

package/dist/components/primitives/button.js

@@ -2,40 +2,24 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { cx } from "./cx.js";
-// Each variant resets the UA button border itself: no preflight ships with
-// the package, so every shape states its own `border-0` rather than
-// inheriting the host page's idea of what a button looks like.
 const VARIANT_CLASSES = {
     primary: "tf:justify-center tf:rounded-full tf:border-0 tf:px-3 tf:py-1.5 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-primary tf:text-tf-primary-foreground tf:shadow-tf-control " +
         "tf:hover:opacity-90 tf:disabled:opacity-50",
     ghost: "tf:justify-center tf:rounded-tf tf:border-0 tf:px-3 tf:py-1.5 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent tf:disabled:opacity-50",
-    // Nothing to send is a resting state, not a broken one: the disabled
-    // circle steps back to the muted wash instead of showing a filled ink
-    // button at 40% — a washed-out primary reads as a rendering fault.
     send: "tf:size-8 tf:shrink-0 tf:justify-center tf:rounded-full tf:border-0 " +
         "tf:bg-tf-primary tf:text-tf-primary-foreground tf:shadow-tf-control " +
         "tf:hover:opacity-90 tf:disabled:bg-tf-muted tf:disabled:text-tf-muted-foreground " +
         "tf:disabled:opacity-100 tf:disabled:shadow-none",
-    // The send circle's busy-state counterpart: same silhouette, filled-ink
-    // register even through the "Stopping…" beat. That beat is narrated
-    // with aria-disabled, never the disabled attribute — disabling the
-    // focused control drops keyboard focus to <body>.
     stop: "tf:size-8 tf:shrink-0 tf:justify-center tf:rounded-full tf:border-0 " +
         "tf:bg-tf-primary tf:text-tf-primary-foreground tf:shadow-tf-control " +
         "tf:hover:opacity-90 tf:aria-disabled:cursor-not-allowed tf:aria-disabled:opacity-70",
     icon: "tf:size-7 tf:justify-center tf:rounded-tf tf:border-0 tf:bg-tf-transparent tf:text-tf-muted-foreground " +
         "tf:hover:bg-tf-accent tf:hover:text-tf-foreground tf:disabled:opacity-50",
-    // A floating icon control: round, on its own paper plate with a hairline
-    // and the control wash, for glyphs hovering over arbitrary pixels. A
-    // VARIANT, not a caller className: cx is a plain join, so a caller's
-    // bg-tf-background loses to icon's own bg-tf-transparent by sheet order.
     iconFloating: "tf:justify-center tf:rounded-full tf:border tf:bg-tf-background " +
         "tf:text-tf-muted-foreground tf:shadow-tf-control " +
         "tf:hover:bg-tf-accent tf:hover:text-tf-foreground tf:disabled:opacity-50",
-    // 32px at 14px medium — the app's measured rail register, so the
-    // assistant's history reads at the same density as the docs tree.
     row: "tf:h-8 tf:w-full tf:justify-start tf:rounded-tf tf:border-0 tf:px-2.5 tf:text-left tf:text-sm tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-muted-foreground tf:hover:bg-tf-accent " +
         "tf:hover:text-tf-foreground tf:aria-[current=true]:bg-tf-accent " +
@@ -43,25 +27,14 @@ const VARIANT_CLASSES = {
     rowAction: "tf:h-9 tf:w-full tf:justify-start tf:gap-2 tf:rounded-tf tf:border-0 tf:px-2.5 tf:text-left tf:text-sm " +
         "tf:font-medium tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent " +
         "tf:disabled:opacity-50",
-    // The drawer's rows clear the 44px touch floor and read a step larger:
-    // a phone is held further away than a rail is leaned over.
     rowTouch: "tf:h-11 tf:w-full tf:justify-start tf:gap-2 tf:rounded-tf tf:border-0 tf:px-3 tf:text-left " +
         "tf:text-tf-body tf:font-medium tf:bg-tf-transparent tf:text-tf-muted-foreground " +
         "tf:hover:bg-tf-accent tf:hover:text-tf-foreground " +
         "tf:aria-[current=true]:bg-tf-accent tf:aria-[current=true]:text-tf-foreground " +
         "tf:disabled:opacity-50",
-    // The drawer's edition of rowAction. A variant rather than a colour
-    // override on rowTouch: cx is a plain join, so a passed text-tf-foreground
-    // and rowTouch's own muted ink land at equal specificity and the
-    // later-emitted utility (the muted one) wins.
     rowActionTouch: "tf:h-11 tf:w-full tf:justify-start tf:gap-2 tf:rounded-tf tf:border-0 tf:px-3 tf:text-left " +
         "tf:text-tf-body tf:font-medium tf:bg-tf-transparent tf:text-tf-foreground " +
         "tf:hover:bg-tf-accent tf:disabled:opacity-50",
-    // The opening prompts. A row, not a pill: three pills of unequal width
-    // centre-justified make a ragged line, and rows survive a 390px column.
-    // The trailing arrow is held at zero opacity rather than unmounted so
-    // the right edge never twitches. px-4 puts the leading glyph on the
-    // composer's own text inset, hanging off the chat bar's left edge.
     prompt: "tf:min-h-11 tf:w-full tf:justify-start tf:gap-2.5 tf:rounded-tf tf:border-0 tf:px-4 tf:py-2 " +
         "tf:text-left tf:text-tf-label tf:bg-tf-transparent tf:text-tf-foreground " +
         "tf:hover:bg-tf-accent tf:disabled:opacity-50 " +
@@ -69,54 +42,25 @@ const VARIANT_CLASSES = {
         "tf:[&_[data-tf-prompt-go]]:opacity-0 tf:[&_[data-tf-prompt-go]]:transition-opacity " +
         "tf:hover:[&_[data-tf-prompt-go]]:opacity-100 " +
         "tf:focus-visible:[&_[data-tf-prompt-go]]:opacity-100 " +
-        // Touch has no hover to reveal the go arrow; it stays visible there.
         "tf:pointer-coarse:[&_[data-tf-prompt-go]]:opacity-100",
-    // A button that draws nothing of its own — for content that IS the
-    // affordance (the companion perch's mark, the bubble's sentence). Keeps
-    // the focus ring, resets the UA chrome, and takes the surrounding ink:
-    // the UA's buttontext would paint black on a dark popover.
     bare: "tf:rounded-tf tf:border-0 tf:bg-tf-transparent tf:p-0 tf:text-inherit tf:disabled:opacity-50",
-    // The composer shelf's chip (the provider/model slot): a quiet rounded
-    // control at the 13px label step. Two emphases as two variants (cx is a
-    // plain join, so emphasis has to be the variant's): `chip` keeps full
-    // ink for an affordance that asks, `chipQuiet` is the settled standing's.
     chip: "tf:rounded-full tf:border-0 tf:px-2 tf:py-1 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-foreground tf:hover:bg-tf-accent " +
         "tf:disabled:opacity-50",
     chipQuiet: "tf:rounded-full tf:border-0 tf:px-2 tf:py-1 tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-transparent tf:text-tf-muted-foreground tf:hover:bg-tf-accent " +
         "tf:hover:text-tf-foreground tf:disabled:opacity-50",
-    // A bounded secondary action/status control. It shares the pill
-    // silhouette with the composer's chips, but keeps a hairline so it is
-    // unmistakably interactive inside a floating menu.
-    outline: "tf:justify-center tf:rounded-full tf:border tf:px-2.5 tf:py-1 tf:text-tf-label tf:font-medium " +
+    outline: "tf:justify-center tf:rounded-full tf:border tf:px-2.5 tf:py-[5px] tf:text-tf-label tf:font-medium " +
         "tf:bg-tf-background tf:text-tf-foreground tf:shadow-tf-control " +
         "tf:hover:bg-tf-accent tf:disabled:opacity-50",
-    // The question panel's answer row: one suggestion per line, spanning
-    // the panel, on the 44px touch floor. Selection is the emphasis wash,
-    // via aria-checked — state speaks through the attribute the screen
-    // reader already gets (No-Accent: never a color). Borderless: the
-    // row's edges are the panel's.
     answerRow: "tf:min-h-11 tf:w-full tf:items-start tf:justify-start tf:gap-3 tf:rounded-tf tf:border-0 " +
         "tf:bg-tf-transparent tf:px-3 tf:py-2.5 tf:text-left tf:text-tf-label tf:text-tf-foreground " +
         "tf:wrap-anywhere tf:hover:bg-tf-accent tf:disabled:opacity-50 " +
         "tf:aria-checked:bg-tf-emphasis",
 };
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props — and callers
-// that anchor to the element (the drawer's history disclosure, the focus
-// hand-backs) need the ref to attach.
 export const TfButton = forwardRef(function TfButton({ variant = "primary", className, type, ...props }, ref) {
     return (_jsx("button", { ref: ref, type: type ?? "button", className: cx("tf:appearance-none", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", "tf:disabled:cursor-not-allowed", VARIANT_CLASSES[variant], className), ...props }));
 });
-// A navigation wearing the button grammar — for actions whose "click" is
-// a link (the connect panel's approve CTA). Same class source as
-// TfButton so the pill can never drift; no disabled arm, because anchors
-// have none.
 export function TfLinkButton({ variant = "primary", className, children, ...props }) {
-    return (_jsx("a", { className: cx(
-        // no-underline: the UA underlines anchors and no preflight ships
-        // with the package — a pill with an underline reads as a bug.
-        "tf:appearance-none tf:no-underline", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", VARIANT_CLASSES[variant], className), ...props, children: children }));
+    return (_jsx("a", { className: cx("tf:appearance-none tf:no-underline", "tf:inline-flex tf:items-center tf:gap-1.5 tf:transition-colors", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", VARIANT_CLASSES[variant], className), ...props, children: children }));
 }
-//# sourceMappingURL=button.js.map

package/dist/components/primitives/cx.d.ts

@@ -1,2 +1 @@
 export declare function cx(...parts: (string | false | null | undefined)[]): string;
-//# sourceMappingURL=cx.d.ts.map

package/dist/components/primitives/cx.js

@@ -1,6 +1,3 @@
-// Class-name joiner for the primitives layer — the package deliberately
-// carries no styling dependencies.
 export function cx(...parts) {
     return parts.filter(Boolean).join(" ");
 }
-//# sourceMappingURL=cx.js.map

package/dist/components/primitives/dialog.d.ts

@@ -5,4 +5,3 @@ interface TfDialogProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, "o
 }
 export declare function TfDialog({ open, onOpenChange, className, children, onPointerDown: onHostPointerDown, ...props }: TfDialogProps): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=dialog.d.ts.map

package/dist/components/primitives/dialog.js

@@ -5,8 +5,6 @@ import { focusAutofocusTarget } from "./autofocus.js";
 import { cx } from "./cx.js";
 export function TfDialog({ open, onOpenChange, className, children, onPointerDown: onHostPointerDown, ...props }) {
     const dialogRef = useRef(null);
-    // The `open` prop stays authoritative: native closes are reported up,
-    // never applied locally, and this effect is the only writer.
     useEffect(() => {
         const dialog = dialogRef.current;
         if (dialog === null) {
@@ -14,34 +12,19 @@ export function TfDialog({ open, onOpenChange, className, children, onPointerDow
         }
         if (open && !dialog.open) {
             dialog.showModal();
-            // The composer marks itself with data-tf-autofocus; without a mark
-            // the native behavior (first focusable) stands.
             focusAutofocusTarget(dialog, () => dialog.open);
         }
         else if (!open && dialog.open) {
             dialog.close();
         }
     }, [open]);
-    // Esc. Cancelled so the close happens through the controlled cycle.
     const closeFromCancel = useCallback((event) => {
         event.preventDefault();
         onOpenChange(false);
     }, [onOpenChange]);
-    // Safety net for a native close that skipped `cancel` (a
-    // method="dialog" form, or a browser force-closing on repeated Esc).
     const closeFromNativeClose = useCallback(() => {
         onOpenChange(false);
     }, [onOpenChange]);
-    // With zero own padding, the only place a press lands on the dialog
-    // element itself is the ::backdrop. The click alone can't be trusted:
-    // it dispatches on the common ancestor of pointerdown and pointerup,
-    // so a text selection that starts in content and releases past the
-    // panel edge also "clicks" the dialog — only a press that BEGAN on the
-    // backdrop counts.
-    //
-    // Composed, not overridden: the spread below lands after every handler
-    // on the element, so a caller passing its own onPointerDown (the sheet's
-    // drag) would silently take this one's place and with it click-to-close.
     const pressBeganOnBackdropRef = useRef(false);
     const trackPressOrigin = useCallback((event) => {
         pressBeganOnBackdropRef.current = event.target === event.currentTarget;
@@ -53,17 +36,5 @@ export function TfDialog({ open, onOpenChange, className, children, onPointerDow
             onOpenChange(false);
         }
     }, [onOpenChange]);
-    return (
-    // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions, jsx-a11y/click-events-have-key-events -- backdrop click-to-close; keyboard users close via Esc (the native cancel event)
-    _jsx("dialog", { ref: dialogRef, 
-        // `hidden` restates the UA's closed-dialog display so the open:flex
-        // override can't leak onto the closed-but-mounted element. The
-        // important marker's collision rationale is historical: it guarded
-        // against a host build re-declaring `.hidden` after this element's
-        // `open:flex` — with the tf: prefix no host build can generate a
-        // colliding name. Kept as ordering insurance between the sheet's
-        // own tf:hidden and tf:open:flex rules, immune to any future
-        // intra-sheet order or specificity drift.
-        className: cx("tf:hidden tf:p-0 tf:open:flex!", className), onCancel: closeFromCancel, onClose: closeFromNativeClose, onPointerDown: trackPressOrigin, onClick: closeFromBackdropClick, ...props, children: children }));
+    return (_jsx("dialog", { ref: dialogRef, className: cx("tf:hidden tf:p-0 tf:open:flex!", className), onCancel: closeFromCancel, onClose: closeFromNativeClose, onPointerDown: trackPressOrigin, onClick: closeFromBackdropClick, ...props, children: children }));
 }
-//# sourceMappingURL=dialog.js.map

package/dist/components/primitives/disclosure.d.ts

@@ -4,42 +4,19 @@ interface DisclosureProps {
     summary: ReactNode;
     children: ReactNode;
     variant?: DisclosureVariant;
-    /** true opens the disclosure and re-opens it on every VALUE change
-     *  back to true (React re-writes the attribute only when the prop
-     *  value changes — see the nativeOpen comment below — so a visitor's
-     *  collapse of a held-open details sticks until the next flip);
-     *  undefined leaves it native — pass `condition || undefined` so the
-     *  true→undefined transition auto-collapses once, then hands toggling
-     *  back to the visitor. */
     open?: boolean;
     className?: string;
     summaryClassName?: string;
     bodyClassName?: string;
-    /** data-* identity hooks spread onto the <details> root (the tool
-     *  row's data-tf-tool-call-id, which the approval banner's
-     *  Show-request affordance resolves). Undefined for every other
-     *  consumer — zero DOM change where unused. */
     rootDataAttributes?: Record<`data-${string}`, string>;
 }
 interface DisclosureVisualState {
     open: boolean;
     summaryActive: boolean;
 }
-/** The disclosure's DOM-backed visual state, for summary content that
- *  renders differently open vs closed (the fold headline's collapsed
- *  step label — the same mirror the chevron rotates on). Only readable
- *  INSIDE the summary: the provider deliberately wraps the summary
- *  children alone, and the read is the DOM's `open` (see the nativeOpen
- *  comment below), never the prop — a visitor can collapse a force-opened
- *  details while the prop still reads true. Null outside any Disclosure
- *  summary. */
 export declare function useDisclosureVisualState(): DisclosureVisualState | null;
 export declare function Disclosure({ summary, children, variant, open, className, summaryClassName, bodyClassName, rootDataAttributes, }: DisclosureProps): import("react").JSX.Element;
 export declare function DisclosureChevron({ revealOnInteraction, }?: {
-    /** Keep quiet summaries free of permanent arrow furniture. Keyboard
-     *  focus mirrors hover so the disclosure never loses its affordance
-     *  for non-pointer navigation. */
     revealOnInteraction?: boolean;
 }): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=disclosure.d.ts.map

package/dist/components/primitives/disclosure.js

@@ -3,33 +3,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { createContext, useContext, useState } from "react";
 import { cx } from "./cx.js";
 const DisclosureVisualStateContext = createContext(null);
-/** The disclosure's DOM-backed visual state, for summary content that
- *  renders differently open vs closed (the fold headline's collapsed
- *  step label — the same mirror the chevron rotates on). Only readable
- *  INSIDE the summary: the provider deliberately wraps the summary
- *  children alone, and the read is the DOM's `open` (see the nativeOpen
- *  comment below), never the prop — a visitor can collapse a force-opened
- *  details while the prop still reads true. Null outside any Disclosure
- *  summary. */
 export function useDisclosureVisualState() {
     return useContext(DisclosureVisualStateContext);
 }
 export function Disclosure({ summary, children, variant = "framed", open, className, summaryClassName, bodyClassName, rootDataAttributes, }) {
-    // The package cannot rely on a consuming application's Tailwind scan to
-    // emit selectors for arbitrary parent states such as
-    // `[summary:hover_&]` or `[[open]>summary_&]`. Keep the native details as
-    // the source of truth, mirror only the two visual facts the chevron
-    // needs, and hand them to the summary's affordance through context.
-    // This makes the behavior identical in the package fixture and in a host
-    // that consumes only the built JavaScript.
     const [nativeOpen, setNativeOpen] = useState(open === true);
     const [summaryActive, setSummaryActive] = useState(false);
-    return (
-    // No `group` class here on purpose: a group variant on a nestable
-    // disclosure matches ANY open ancestor (see DisclosureChevron below),
-    // so the hook stays unwired rather than inviting the next consumer
-    // to re-create the nested-chevron bug. Anchor on [open]>summary.
-    _jsxs("details", { ...rootDataAttributes, open: open, onToggle: (event) => {
+    return (_jsxs("details", { ...rootDataAttributes, open: open, onToggle: (event) => {
             setNativeOpen(event.currentTarget.open);
         }, className: cx(variant === "framed" && "tf:rounded-tf tf:border", className), children: [_jsx("summary", { onMouseEnter: () => {
                     setSummaryActive(true);
@@ -40,34 +20,8 @@ export function Disclosure({ summary, children, variant = "framed", open, classN
                 }, onBlur: () => {
                     setSummaryActive(false);
                 }, className: cx("tf:cursor-pointer tf:list-none tf:select-none tf:[&::-webkit-details-marker]:hidden", "tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", variant === "framed" &&
-                    "tf:flex tf:items-center tf:gap-2 tf:px-3 tf:py-1.5 tf:text-tf-label", summaryClassName), children: _jsx(DisclosureVisualStateContext.Provider
-                // nativeOpen ALONE, never `open === true || nativeOpen`: React
-                // re-writes the open attribute only when the prop VALUE changes,
-                // so after a visitor collapses a force-opened details the DOM is
-                // closed while the prop still reads true — the [open]>summary
-                // selector this mirror replaced always read the DOM, and so must
-                // the mirror. nativeOpen is seeded from the prop at mount and a
-                // later undefined→true flip lands through onToggle.
-                , { 
-                    // nativeOpen ALONE, never `open === true || nativeOpen`: React
-                    // re-writes the open attribute only when the prop VALUE changes,
-                    // so after a visitor collapses a force-opened details the DOM is
-                    // closed while the prop still reads true — the [open]>summary
-                    // selector this mirror replaced always read the DOM, and so must
-                    // the mirror. nativeOpen is seeded from the prop at mount and a
-                    // later undefined→true flip lands through onToggle.
-                    value: { open: nativeOpen, summaryActive }, children: summary }) }), _jsx("div", { className: cx(variant === "framed" && "tf:border-t tf:px-3 tf:py-2", bodyClassName), children: children })] }));
+                    "tf:flex tf:items-center tf:gap-2 tf:px-3 tf:py-1.5 tf:text-tf-label", summaryClassName), children: _jsx(DisclosureVisualStateContext.Provider, { value: { open: nativeOpen, summaryActive }, children: summary }) }), _jsx("div", { className: cx(variant === "framed" && "tf:border-t tf:px-3 tf:py-2", bodyClassName), children: children })] }));
 }
-// Rotates when its OWN Disclosure is open. Not the group-open hook:
-// every Tailwind group variant (named or not) compiles to an
-// ancestor-matching selector, so inside a nested Disclosure — a tool
-// row inside an open fold — the outer open details would keep an inner
-// chevron rotated forever. The [open]>summary anchor can't leak across
-// nesting levels, because a chevron's only <summary> ancestor is its
-// own (a details' body is never inside another details' summary).
-// The framed variant hides the native marker, so summaries that carry no
-// other trailing affordance MUST place this — a markerless summary reads
-// as an inert box, invisible as a control.
 export function DisclosureChevron({ revealOnInteraction = false, } = {}) {
     const visualState = useContext(DisclosureVisualStateContext);
     const isOpen = visualState?.open === true;
@@ -76,4 +30,3 @@ export function DisclosureChevron({ revealOnInteraction = false, } = {}) {
             ? "tf:transition-[opacity,transform]"
             : "tf:transition-transform"), children: _jsx("path", { d: "M6 4l4 4-4 4", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) }));
 }
-//# sourceMappingURL=disclosure.js.map

package/dist/components/primitives/file-input.d.ts

@@ -3,4 +3,3 @@ export declare const TfFileInput: import("react").ForwardRefExoticComponent<{
     multiple?: boolean;
     onPickFiles: (files: FileList | null) => void;
 } & import("react").RefAttributes<HTMLInputElement>>;
-//# sourceMappingURL=file-input.d.ts.map

package/dist/components/primitives/file-input.js

@@ -1,17 +1,9 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
-// The package's one file control: a visually hidden native input a
-// visible button drives via ref (the shell ImageRow pattern). Hidden
-// rather than styled — a native file control cannot wear the register,
-// so the affordance is always a TfButton and this is its mechanism.
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props.
 export const TfFileInput = forwardRef(function TfFileInput({ accept, multiple = false, onPickFiles }, ref) {
     return (_jsx("input", { ref: ref, type: "file", accept: accept, multiple: multiple, className: "tf:sr-only", tabIndex: -1, "aria-hidden": "true", onChange: (event) => {
             onPickFiles(event.target.files);
-            // Clearing lets the same file re-fire a change event.
             event.target.value = "";
         } }));
 });
-//# sourceMappingURL=file-input.js.map

package/dist/components/primitives/floating-panel.d.ts

@@ -4,20 +4,12 @@ type FloatingPanelDock = "floating" | "sidebar";
 interface TfFloatingPanelProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;
-    /** The viewport corner the panel anchors to. The companion sits in the
-     * same corner; its clearance is the consumer's className. */
     corner?: FloatingPanelCorner;
-    /** Where the panel lives: the floating corner card (default), or the
-     * full-height sidebar docked flush to the right edge with the host
-     * page pushed aside. The sidebar ignores `corner` — right-edge only. */
     dock?: FloatingPanelDock;
     "aria-label": string;
-    /** The open is the visitor's own gesture, so the content's
-     *  data-tf-autofocus mark may take the caret; read as of the open. */
     focusOnOpen: boolean;
     className?: string;
     children: ReactNode;
 }
 export declare function TfFloatingPanel({ open, onOpenChange, corner, dock, focusOnOpen, className, children, ...props }: TfFloatingPanelProps): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=floating-panel.d.ts.map