@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/approval-card.js

@@ -9,25 +9,11 @@ import { TfTextarea } from "./primitives/textarea.js";
 import { Spinner } from "./streaming-states.js";
 export const APPROVED_NOTE = "Approved";
 export const TRUSTED_NOTE = "Approved — the assistant won't ask about this again in this conversation.";
-// The coworker's twin: the grant is its own session's, so the note names
-// the actor and the scope the button promised.
 const COWORKER_TRUSTED_NOTE = "Approved — the coworker won't ask about this again in this task.";
-// "Not approved", not "Denied": the row this decision settles into
-// wears the same word on its pill and headline, so the banner's footer
-// — the decision's only other rendered home — says one word for one
-// fact. "Declined" stays the door's (TVC-038).
 export const DENIED_NOTE = "Not approved — the assistant has been told.";
-// A coworker's card speaks of the coworker: who asked is who
-// hears the answer.
 const COWORKER_DENIED_NOTE = "Not approved — the coworker has been told.";
 const STALE_NOTE = "This request was already answered or expired.";
-// The gate's asks are strictly per-call; saying so is what makes the
-// third ask read as policy instead of amnesia (and explains why the
-// approve-and-stop-asking control is missing).
 const GATED_NOTE = "This action asks every time.";
-// Module-private: the transcript's settled decision lines that shared
-// this spelling went with the meta-receipt rows; the card's own footer
-// below is the note's one rendered home.
 function approvalSettledNoteOf(status, asker) {
     switch (status.kind) {
         case "answered":
@@ -47,43 +33,8 @@ function approvalSettledNoteOf(status, asker) {
             return null;
     }
 }
-/**
- * One approval entry point: the package's generic banner. It asks one
- * question — the backend-authored consent sentence over a mechanically
- * spelled tool label — and no longer presents the tool call.
- *
- * The consent doctrine: informed consent is carried by the TRANSCRIPT
- * ROW, which a pending decision always opens — the placement guarantee:
- * `heldRowOpen` in tool-row.tsx holds the affected row and its fold open
- * from the durable decision arm that core/tool-decision-anchors.ts folds
- * out of the event history, so the arguments are on screen
- * (replay-identically, reload included) without this banner carrying
- * them. The "Show request" affordance below scrolls to that row.
- *
- * Moving the arguments off this surface weakens no enforcement, because
- * the re-ask rule — "ask again iff the card would render differently" —
- * was doctrine in a comment, never a mechanism: trust is recorded and
- * looked up by EXACT tool name (the serving side's interventions module;
- * the vended SDK's ledger is `hitl:trusted_tools`, a plain list of
- * tool-name strings in agent state), and no argument digest exists
- * anywhere in the codebase (no trust key, storage column or inbox key
- * anywhere derives from a call's arguments). Nothing mechanical ever
- * depended on this surface's fidelity to the arguments.
- *
- * Everything rendered stays a pure function of the card model: stable
- * ordering, no clocks, no locale — two identical requests render
- * byte-identical banners.
- *
- * The durable status (submitting, answered, stale) lives in the inbox so
- * a transcript remount can never resurrect the buttons; the local state
- * is the deny-reveals-textarea step and the synchronous double-click
- * guard — and local state may only ever ADD dead-ness: the buttons'
- * existence stays the inbox's call, the guard merely disables them in
- * the same tick the click lands, before any store round-trip.
- */
 export function ApprovalCard({ card }) {
     const { submitDecision } = useContext(ApprovalsContext);
-    const rootRef = useRef(null);
     const [denying, setDenying] = useState(false);
     const [feedback, setFeedback] = useState("");
     const submittedForStatusRef = useRef(null);
@@ -98,9 +49,7 @@ export function ApprovalCard({ card }) {
         setSubmittedForStatus(card.status);
         void submitDecision(card, decision);
     };
-    return (_jsxs("div", { ref: rootRef, "data-tf-approval-card": "", className: "tf:my-2 tf:rounded-2xl tf:border tf:border-tf-border tf:bg-tf-card tf:p-4", role: "group", "aria-label": "Approval request", children: [_jsx(CardHeader, { card: card, onShowRequest: () => {
-                    _showRequest(rootRef.current, card.toolCallId);
-                } }), _jsx("p", { "data-tf-approval-prompt": "", className: "tf:mt-3 tf:m-0 tf:text-tf-label tf:leading-relaxed tf:text-tf-muted-foreground", children: card.prompt.trim() === ""
+    return (_jsxs("div", { "data-tf-approval-card": "", className: "tf:my-2 tf:rounded-2xl tf:border tf:border-tf-border tf:bg-tf-card tf:p-4", role: "group", "aria-label": "Approval request", children: [_jsx(CardHeader, { card: card }), _jsx("p", { "data-tf-approval-prompt": "", className: "tf:mt-3 tf:m-0 tf:text-tf-label tf:leading-relaxed tf:text-tf-muted-foreground", children: card.prompt.trim() === ""
                     ? "This tool needs your approval before it can run."
                     : card.prompt }), _jsx("div", { "data-tf-approval-footer": "", children: _jsx(CardFooter, { card: card, denying: denying, submitted: submitted, feedback: feedback, onFeedbackChange: setFeedback, onApprove: () => {
                         submitOnce({ approved: true });
@@ -118,22 +67,8 @@ export function ApprovalCard({ card }) {
                         });
                     } }) })] }));
 }
-function CardHeader({ card, onShowRequest, }) {
-    return (_jsxs("div", { className: "tf:flex tf:min-w-0 tf:items-start tf:justify-between tf:gap-3", children: [_jsxs("div", { className: "tf:min-w-0", children: [_jsx("p", { "data-tf-approval-title": "", className: "tf:m-0 tf:text-tf-heading tf:font-semibold", children: "Approval required" }), _jsx("p", { className: "tf:mt-0.5 tf:m-0 tf:truncate tf:font-mono tf:text-xs tf:text-tf-muted-foreground", children: _toolDisplayNameOf(card.toolName) }), card.asker.kind === "coworker" ? (_jsxs("p", { "data-tf-approval-asker": "", className: "tf:mt-1 tf:m-0 tf:truncate tf:text-xs tf:text-tf-muted-foreground", children: ["Asked by a coworker \u2014 ", _coworkerLabelOf(card.asker.label)] })) : null] }), card.toolCallId !== null && card.asker.kind === "assistant" ? (
-            // Gated on MODEL data alone, stated premise: on a row-less
-            // REST-recovered pause this button renders and its click is a
-            // quiet no-op — an inert-but-present control is the accepted
-            // cost there, pinned by its test. Gating on DOM presence
-            // instead (a layout-effect lookup of the row) would make the
-            // render a function of the mount environment — breaking "two
-            // identical requests render byte-identical banners" and
-            // re-introducing, as a DOM probe, exactly the row join this
-            // reshape deleted.
-            //
-            // shrink-0 + nowrap: the affordance never wraps to two lines
-            // at the narrow measure — the title column beside it owns the
-            // squeeze (its label already truncates).
-            _jsx(TfButton, { variant: "ghost", className: "tf:shrink-0 tf:whitespace-nowrap", "data-tf-approval-show-request": "", onClick: onShowRequest, children: "Show request" })) : null] }));
+function CardHeader({ card }) {
+    return (_jsxs("div", { className: "tf:min-w-0", children: [_jsx("p", { "data-tf-approval-title": "", className: "tf:m-0 tf:text-tf-heading tf:font-semibold", children: "Approval required" }), _jsx("p", { className: "tf:mt-0.5 tf:m-0 tf:truncate tf:font-mono tf:text-xs tf:text-tf-muted-foreground", children: _toolDisplayNameOf(card.toolName) }), card.asker.kind === "coworker" ? (_jsxs("p", { "data-tf-approval-asker": "", className: "tf:mt-1 tf:m-0 tf:truncate tf:text-xs tf:text-tf-muted-foreground", children: ["Asked by a coworker \u2014 ", _coworkerLabelOf(card.asker.label)] })) : null] }));
 }
 function CardFooter({ card, denying, submitted, feedback, onFeedbackChange, onApprove, onApproveAndTrust, onStartDenying, onStopDenying, onSendDenial, }) {
     switch (card.status.kind) {
@@ -156,72 +91,9 @@ function DenialForm({ asker, feedback, submitted, onFeedbackChange, onSend, onBa
 function DecisionButtons({ card, submitted, onApprove, onApproveAndTrust, onStartDenying, }) {
     return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:flex-wrap tf:gap-2", children: [_jsx(TfButton, { disabled: submitted, onClick: onApprove, children: "Approve" }), _cardOffersTrust(card) ? (_jsx(TfButton, { variant: "ghost", disabled: submitted, onClick: onApproveAndTrust, children: _trustLabelOf(card.asker) })) : null, _jsx(TfButton, { variant: "ghost", disabled: submitted, onClick: onStartDenying, children: "Deny" })] }), card.gated ? (_jsx("p", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: GATED_NOTE })) : null] }));
 }
-/** The Show-request navigation: reveal the banner's call's transcript
- *  row and scroll it into view. Scoped to the closest
- *  [data-tf-conversation], like the tenant's own focus hand-off
- *  (suspension-surfaces.tsx): surfaces can mount Transcript concurrently
- *  (the page under an open palette), and a root-scoped query would
- *  resolve the FIRST column's row; the root node (document or shadow
- *  root) is the fallback for bare hosts. A missing row (a REST-recovered
- *  pause whose call never reached the transcript, a pruned history) is a
- *  quiet no-op — never a throw. Scroll only, no focus move: the member
- *  is going to READ the request and come back to Approve/Deny, and
- *  yanking focus would exercise the tenant's blur-disarm for nothing. */
-function _showRequest(from, toolCallId) {
-    if (from === null || toolCallId === null) {
-        return;
-    }
-    const scope = from.closest("[data-tf-conversation]") ??
-        from.getRootNode();
-    const row = scope.querySelector(`[data-tf-tool-call-id="${CSS.escape(toolCallId)}"]`);
-    if (row === null) {
-        return;
-    }
-    // ESTABLISH the state the navigation needs, don't assume it: the
-    // placement hold is releasable in both directions on purpose — a
-    // member's collapse of a held-open row sticks until a genuine arrival
-    // (tool-row.tsx), and one explicit toggle pins the enclosing fold to
-    // native <details> for its lifetime (use-member-toggle-outrank.ts).
-    // Both rulings stand untouched: this imperative open is a
-    // MEMBER-INITIATED reveal — the member just clicked "Show request" —
-    // which is categorically different from a hold re-asserting itself
-    // over a member's toggle.
-    // It writes only the native open state (each set fires a toggle
-    // event, so the Disclosure mirror stays honest), and the walk covers
-    // the row itself plus every enclosing fold, since a closed fold gives
-    // the row no box for scrollIntoView to target at all.
-    for (let enclosing = row.closest("details"); enclosing !== null; enclosing = enclosing.parentElement?.closest("details") ?? null) {
-        enclosing.open = true;
-    }
-    // The row's own summary, not the details: an open pending row can be
-    // taller than the viewport, and centering the whole pane would put its
-    // header off screen.
-    const target = row.querySelector(":scope > summary") ?? row;
-    // jsdom has no scrollIntoView (same guard as affordances/highlight.ts).
-    if (typeof target.scrollIntoView !== "function") {
-        return;
-    }
-    target.scrollIntoView({
-        block: "center",
-        inline: "nearest",
-        behavior: _reducedMotionIsOn(target) ? "auto" : "smooth",
-    });
-}
-function _reducedMotionIsOn(target) {
-    // Both switches, like every animated surface in the package
-    // (streaming-states.tsx): the OS preference and the host kill switch —
-    // walked from the scroll TARGET so the check is shadow-root correct
-    // for the row being scrolled to.
-    return ((typeof window.matchMedia === "function" &&
-        window.matchMedia("(prefers-reduced-motion: reduce)").matches) ||
-        target.closest('[data-reduce-motion="true"]') !== null);
-}
 function _cardOffersTrust(card) {
-    // Off the wire for either asker; the locked gate never offers it.
     return !card.gated && card.trustAvailable;
 }
-// The consent sentence names the grant's scope, which is the asker's
-// session: the thread for the assistant, the task for a coworker.
 function _trustLabelOf(asker) {
     return asker.kind === "coworker"
         ? "Approve for this task"
@@ -243,4 +115,3 @@ function _toolDisplayNameOf(toolName) {
         ? toolName
         : humanized[0].toUpperCase() + humanized.slice(1);
 }
-//# sourceMappingURL=approval-card.js.map

package/dist/components/approval-context.d.ts

@@ -4,9 +4,5 @@ export interface ApprovalSurface {
     submitDecision: (card: ApprovalCardModel, decision: ApprovalDecisionInput) => Promise<void>;
 }
 export declare const ApprovalsContext: import("react").Context<ApprovalSurface>;
-/** The approval surface — live under <TeaflaskAssistantProvider>;
- *  outside one it is the inert-but-loud guard above, so a stray
- *  submit still refuses to dissolve into a no-op. */
 export declare function useApprovals(): ApprovalSurface;
 export declare function anchoredCardsFor(cards: readonly ApprovalCardModel[], toolCallId: string): ApprovalCardModel[];
-//# sourceMappingURL=approval-context.d.ts.map

package/dist/components/approval-context.js

@@ -1,11 +1,5 @@
 "use client";
 import { createContext, useContext } from "react";
-// Inert for rendering, loud on use: the empty-state composer renders
-// outside any transcript, where nothing can be paused — but a decision
-// on a safety-critical control must never dissolve into a successful
-// no-op, so an out-of-surface submit says so in the console and
-// rejects. Callers void the promise, which makes the rejection an
-// unhandled one on purpose: it reaches the host's exception capture.
 const EMPTY_APPROVAL_SURFACE = {
     cards: [],
     submitDecision: (card) => {
@@ -15,13 +9,9 @@ const EMPTY_APPROVAL_SURFACE = {
     },
 };
 export const ApprovalsContext = createContext(EMPTY_APPROVAL_SURFACE);
-/** The approval surface — live under <TeaflaskAssistantProvider>;
- *  outside one it is the inert-but-loud guard above, so a stray
- *  submit still refuses to dissolve into a no-op. */
 export function useApprovals() {
     return useContext(ApprovalsContext);
 }
 export function anchoredCardsFor(cards, toolCallId) {
     return cards.filter((card) => card.anchored && card.toolCallId === toolCallId);
 }
-//# sourceMappingURL=approval-context.js.map

package/dist/components/assistant-companion.d.ts

@@ -1,15 +1,5 @@
 export interface AssistantCompanionProps {
-    /** The viewport corner the companion (and its drawer) anchor to. */
     corner?: "bottom-right" | "bottom-left";
-    /** Accessible name of the open-assistant control. */
     "aria-label"?: string;
 }
-/** The export is the boundary: a throw anywhere in this surface — its
- *  own hooks included — never unmounts the host's tree.
- *  degrade="silent": this is an overlay mount sitting as a sibling at
- *  the end of the host's tree, so the in-flow fallback card would land
- *  as a stray block on the host page — absence is the honest degraded
- *  state, and onError + the console report identically. Unkeyed
- *  backstop: it clears when the host remounts the surface. */
 export declare function AssistantCompanion(props: AssistantCompanionProps): import("react").JSX.Element;
-//# sourceMappingURL=assistant-companion.d.ts.map

package/dist/components/assistant-companion.js

@@ -13,23 +13,7 @@ import { SurfaceBoundary } from "./surface-boundary.js";
 import { useAssistantSurfacePresence } from "./use-assistant-surface-presence.js";
 import { usePerchClearance } from "./use-perch-clearance.js";
 import { useCell } from "./use-store-cell.js";
-// How long a dismissed drawer stays mounted so the stylesheet's 220ms
-// exit run gets to paint (unmounting kills it before hidePopover() can
-// start it), with room for a busy frame. A timer, not transitionend:
-// the widget holds no ref into the panel two components down, and a
-// listener that never fires would hold the mount forever (dock-reflow's
-// law). Erring long is invisible — once the run lands the closed
-// popover is display:none. Reduced motion deliberately takes the same
-// path: the stylesheet already collapses the run to a 1ms cut, and the
-// rest of the hold keeps only a hidden node mounted.
 const DRAWER_EXIT_HOLD_MS = 400;
-/** The export is the boundary: a throw anywhere in this surface — its
- *  own hooks included — never unmounts the host's tree.
- *  degrade="silent": this is an overlay mount sitting as a sibling at
- *  the end of the host's tree, so the in-flow fallback card would land
- *  as a stray block on the host page — absence is the honest degraded
- *  state, and onError + the console report identically. Unkeyed
- *  backstop: it clears when the host remounts the surface. */
 export function AssistantCompanion(props) {
     return (_jsx(SurfaceBoundary, { surface: "companion", degrade: "silent", children: _jsx(AssistantCompanionInner, { ...props }) }));
 }
@@ -40,10 +24,6 @@ function AssistantCompanionInner({ corner = "bottom-right", "aria-label": ariaLa
     const drawer = useCompanionDrawer();
     const panelMode = usePanelMode(publishableKey);
     const sidebarFits = useViewportFitsSidebar();
-    // Below the floor a 26rem sidebar is nonsense — the floating card is
-    // already full-width there. The preference survives untouched; only
-    // the rendering is forced, so a tablet rotated back gets its sidebar
-    // back without re-choosing.
     const dock = sidebarFits && panelMode === "sidebar" ? "sidebar" : "floating";
     const changeDock = useCallback((next) => {
         writePanelMode(publishableKey, next);
@@ -55,19 +35,10 @@ function AssistantCompanionInner({ corner = "bottom-right", "aria-label": ariaLa
     usePerchClearance(dockRef, dockVisible);
     return (_jsxs(_Fragment, { children: [_jsx("div", { ref: dockRef, popover: "manual", "data-tf-assistant": "", "data-tf-companion-dock": corner, onToggle: parkOnForcedHide, ...rootProps, children: chrome === "companion" ? (_jsx(MinimizedCompanion, { ariaLabel: ariaLabel, onOpen: drawer.open })) : null }), chrome === "drawer" || drawer.expanded || drawer.exiting ? (_jsx(CompanionDrawer, { open: chrome === "drawer", exiting: drawer.exiting, focusOnOpen: drawer.openedByGesture, onOpenChange: drawer.changeOpen, corner: corner, dock: dock, onDockChange: sidebarFits ? changeDock : null })) : null] }));
 }
-/** The drawer's open flag — page-level state (core/companion-drawer-flag),
- *  so a tool navigation and a full surface taking the floor write it from
- *  outside this tree and a host remount lands on the same flag — plus the
- *  exit hold, the one clock that is this instance's own. A transient
- *  yield (the palette) never touches the flag, so the drawer returns when
- *  the palette closes. */
 function useCompanionDrawer() {
     const expanded = useCell(companionDrawerOpen);
     const [drawerExiting, setDrawerExiting] = useState(false);
     const [openedByGesture, setOpenedByGesture] = useState(false);
-    // A reopen mid-exit cancels the hold in the same paint (render-time
-    // adjustment), so a minimize that follows starts a full-length hold —
-    // a stale timer from the first exit would truncate the second.
     if (drawerExiting && expanded) {
         setDrawerExiting(false);
     }
@@ -75,11 +46,6 @@ function useCompanionDrawer() {
         setOpenedByGesture(true);
         openCompanionDrawer();
     }, []);
-    // Every deliberate dismissal — the dash, Esc, a swipe — rings this
-    // with false (a yield never does), and the exit hold keeps the panel
-    // mounted through the very commit that flips `open`, so hidePopover()
-    // gets to run and the stylesheet's exit paints instead of a one-frame
-    // cut. The timer below lets go once the run has landed.
     const changeDrawerOpen = useCallback((next) => {
         setOpenedByGesture(next);
         if (next) {
@@ -111,19 +77,9 @@ function useCompanionDrawer() {
 function MinimizedCompanion({ ariaLabel, onOpen, }) {
     return (_jsx("div", { "data-tf-companion-perch": "", children: _jsx(TfButton, { variant: "bare", "data-tf-companion-body": "", "aria-label": ariaLabel, onClick: onOpen, children: _jsx(CompanionMark, {}) }) }));
 }
-/** The durable per-key dock preference, live across every consumer in
- *  this tab. The server snapshot is floating: registration-free SSR, and
- *  hydration corrects itself without a mismatch. */
 function usePanelMode(publishableKey) {
     return useSyncExternalStore(subscribePanelMode, () => readPanelMode(publishableKey), () => "floating");
 }
-// The sidebar's viewport floor. The margin push is invisible to the
-// host's own media queries — a pushed host still *believes* the full
-// viewport width — so below this floor the 26rem pane leaves hosts in
-// a layout their breakpoints never planned for (the dashboard at 800px
-// kept its expanded nav over a ~90px content sliver). 1024 leaves every
-// host at least ~608px, and the phone/tablet cases the ticket named are
-// already covered by the full-width floating card.
 const SIDEBAR_MIN_VIEWPORT_QUERY = "(min-width: 1024px)";
 function _subscribeSidebarViewport(onChange) {
     const media = window.matchMedia(SIDEBAR_MIN_VIEWPORT_QUERY);
@@ -132,21 +88,9 @@ function _subscribeSidebarViewport(onChange) {
         media.removeEventListener("change", onChange);
     };
 }
-/** Whether the viewport clears the sidebar's floor, live across resizes
- *  and rotations. The server snapshot says no — SSR renders the floating
- *  default and hydration corrects without a mismatch. */
 function useViewportFitsSidebar() {
     return useSyncExternalStore(_subscribeSidebarViewport, () => window.matchMedia(SIDEBAR_MIN_VIEWPORT_QUERY).matches, () => false);
 }
-/**
- * The dock's edition of the floating panel's popover discipline: the
- * `visible` argument stays authoritative (machine-driven hides are ours;
- * this effect is the only writer), a forced external hide — a host
- * modal's hide-all-popovers, a meddling hidePopover() — PARKS the dock
- * rather than closing it, and the way-is-clear watcher restores it
- * without touching focus. In a browser without popover support the dock
- * simply never shows (the stylesheet keeps it hidden at rest).
- */
 function useDockPresence(dockRef, visible) {
     const parkedRef = useRef(false);
     useEffect(() => {
@@ -157,9 +101,6 @@ function useDockPresence(dockRef, visible) {
         const doc = dock.ownerDocument;
         const showing = dock.matches(":popover-open");
         if (visible && !showing && !parkedRef.current) {
-            // The same way-must-be-clear check as the restore path: a machine
-            // flip while a host modal is up must park, not punch the dock into
-            // the top layer above the modal's backdrop.
             if (doc.querySelector("dialog:modal") !== null ||
                 doc.fullscreenElement !== null) {
                 parkedRef.current = true;
@@ -204,4 +145,3 @@ function useDockPresence(dockRef, visible) {
         }
     }, [visible]);
 }
-//# sourceMappingURL=assistant-companion.js.map

package/dist/components/assistant-page.d.ts

@@ -1,15 +1,8 @@
 import { type ReactNode } from "react";
 import { type AssistantSuggestionInput } from "./conversation-view.js";
-/**
- * What a host needs to build the surface's chrome somewhere of its own.
- * Handed to `renderChrome`; the history disclosure itself stays the
- * package's.
- */
 export interface AssistantChrome {
     title: string;
-    /** The active thread's title, falling back to the surface title. */
     conversationTitle: string;
-    /** False for anonymous visitors — there is no history to open. */
     historyAvailable: boolean;
     historyOpen: boolean;
     historyMenuId: string;
@@ -19,68 +12,12 @@ export interface AssistantChrome {
     newConversation: () => void;
 }
 export interface AssistantPageProps {
-    /**
-     * Drops the surface's own card chrome (border and radius) so it sits
-     * flush inside chrome the host already draws — a workbench pane, a
-     * full-page route. The default keeps the self-contained card for
-     * drop-in embeds.
-     */
     frameless?: boolean;
-    /**
-     * Opening prompts shown beneath the composer before the first message;
-     * clicking one sends it as if typed. Content belongs to the host —
-     * the package ships none of its own.
-     */
     suggestions?: readonly AssistantSuggestionInput[];
-    /**
-     * One message sent on the host's behalf, as if the visitor had typed it,
-     * when this surface opens on an empty conversation. For a host that
-     * already knows what the visitor came to do — a first run, a deep link
-     * from elsewhere in the app — so they arrive mid-conversation instead of
-     * facing a blank composer. Sent at most once per mount, never over an
-     * existing thread, and never while the sign-in gate is up; the host owns
-     * the one-shot condition, so a value that changes later does nothing.
-     */
     initialPrompt?: string;
-    /**
-     * The invitation above an empty page composer. Hosts can give their
-     * assistant a little voice here ("Let's plan"); the package's neutral
-     * default remains suitable for a customer embed.
-     */
     welcomeTitle?: string;
-    /** Optional host mark shown beside the empty-state invitation. */
     welcomeMark?: ReactNode;
-    /**
-     * The surface's display name, shown in the package's own phone header.
-     * The rail deliberately doesn't repeat it — whatever this is embedded
-     * in has already said where you are. Hosts name it for their own site
-     * ("Acme Help"); the neutral default is "Assistant".
-     */
     title?: string;
-    /**
-     * Takes the phone header off the package's hands. A host whose own
-     * chrome already spends a bar across the top of this surface can put
-     * these controls in it instead of stacking a second row under it —
-     * return portals and this renders nothing in place. Given the chrome's
-     * callbacks rather than its markup, so the host's controls are the
-     * host's; the disclosure they open stays here. Omit it and the package
-     * draws its own strip, which is what a drop-in embed wants.
-     */
     renderChrome?: (chrome: AssistantChrome) => ReactNode;
 }
-/**
- * The full-page surface: the shared conversation core with history as a
- * disclosure over it. Keeping history transient avoids manufacturing a
- * second permanent sidebar beside whatever navigation the host already
- * owns. Anonymous visitors have no history to disclose — the browser
- * holds exactly one thread — so they get only the same start-over action
- * the palette offers. Give it a sized container; it fills that box.
- *
- * The export is the boundary: a throw anywhere in this surface — its own
- * hooks included — degrades to the fallback card instead of unmounting
- * the host's tree. Unkeyed backstop: it clears when the host remounts
- * the surface; the granular boundaries inside recover on their own
- * identities.
- */
 export declare function AssistantPage(props: AssistantPageProps): import("react").JSX.Element;
-//# sourceMappingURL=assistant-page.d.ts.map

package/dist/components/assistant-page.js

@@ -14,48 +14,21 @@ import { TfButton } from "./primitives/button.js";
 import { cx } from "./primitives/cx.js";
 import { useAssistantConversation, } from "./use-assistant-conversation.js";
 import { useRegisterAssistantSurface } from "./use-register-assistant-surface.js";
-// The no-provider fallback (bare-render tests): a frozen no-gate cell, so
-// the hook order never bends. conversation-view holds the twin.
 const NO_GATE_CELL = new ObservableCell(NO_GATE);
-/**
- * The full-page surface: the shared conversation core with history as a
- * disclosure over it. Keeping history transient avoids manufacturing a
- * second permanent sidebar beside whatever navigation the host already
- * owns. Anonymous visitors have no history to disclose — the browser
- * holds exactly one thread — so they get only the same start-over action
- * the palette offers. Give it a sized container; it fills that box.
- *
- * The export is the boundary: a throw anywhere in this surface — its own
- * hooks included — degrades to the fallback card instead of unmounting
- * the host's tree. Unkeyed backstop: it clears when the host remounts
- * the surface; the granular boundaries inside recover on their own
- * identities.
- */
 export function AssistantPage(props) {
     return (_jsx(SurfaceBoundary, { surface: "page", children: _jsx(AssistantPageInner, { ...props }) }));
 }
 function AssistantPageInner({ frameless = false, suggestions, initialPrompt, title = "Assistant", welcomeTitle, welcomeMark, renderChrome, }) {
     const core = useAssistantConversation();
     useInitialPrompt(core, initialPrompt);
-    // The provider's theme/mode props ride onto every data-tf-assistant
-    // root as inline variables and the theme attribute.
     const { rootProps } = useAssistantAppearance();
-    // Registered even in the setup-error branch: the error card still fills
-    // the surface's box, so the companion must yield to it all the same.
     useRegisterAssistantSurface("full-surface");
     const { historyOpen, setHistoryOpen, historyMenuId, historyTriggerId, historyTriggerRef, openHistory, toggleHistory, startFresh, } = useHistoryDisclosure(core);
-    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- an empty server title is the same visual gap as no title while a new thread is being named.
     const conversationTitle = core.conversation?.thread.title || title;
     if (core.setupError !== null) {
         return (_jsx(SetupErrorSurface, { rootProps: rootProps, frameless: frameless, setupError: core.setupError }));
     }
-    return (_jsxs("div", { "data-tf-assistant": "", ...rootProps, className: cx("tf:relative tf:flex tf:h-full tf:min-h-0 tf:w-full tf:overflow-hidden tf:bg-tf-background tf:text-tf-foreground", !frameless && "tf:rounded-tf tf:border"), children: [_jsxs("div", { className: "tf:flex tf:min-h-0 tf:min-w-0 tf:flex-1 tf:flex-col", children: [renderChrome === undefined ? (_jsx(PageHeaderStrip, { title: title, historyExpected: core.historyExpected, historyMenuId: historyMenuId, historyOpen: historyOpen, onHistoryOpenChange: setHistoryOpen, historyTriggerRef: historyTriggerRef, onNewConversation: startFresh })) : (
-                    // data-tf-host-view: renderChrome's output is HOST-authored
-                    // DOM inside the widget root — the sheet's box/border reset
-                    // excludes everything under this marker, so the host's own
-                    // utilities style the host's own chrome. The wrapper is
-                    // display:contents: no box, no layout change.
-                    _jsx("div", { "data-tf-host-view": "", className: "tf:contents", children: renderChrome({
+    return (_jsxs("div", { "data-tf-assistant": "", ...rootProps, className: cx("tf:relative tf:flex tf:h-full tf:min-h-0 tf:w-full tf:overflow-hidden tf:bg-tf-background tf:text-tf-foreground", !frameless && "tf:rounded-tf tf:border"), children: [_jsxs("div", { className: "tf:flex tf:min-h-0 tf:min-w-0 tf:flex-1 tf:flex-col", children: [renderChrome === undefined ? (_jsx(PageHeaderStrip, { title: title, historyExpected: core.historyExpected, historyMenuId: historyMenuId, historyOpen: historyOpen, onHistoryOpenChange: setHistoryOpen, historyTriggerRef: historyTriggerRef, onNewConversation: startFresh })) : (_jsx("div", { "data-tf-host-view": "", className: "tf:contents", children: renderChrome({
                             title,
                             conversationTitle,
                             historyAvailable: core.historyExpected,
@@ -65,17 +38,10 @@ function AssistantPageInner({ frameless = false, suggestions, initialPrompt, tit
                             openHistory,
                             toggleHistory,
                             newConversation: startFresh,
-                        }) })), _jsx(ConversationView, { core: core, surface: "page", suggestions: suggestions, welcomeTitle: welcomeTitle, welcomeMark: welcomeMark })] }), core.historyExpected && historyOpen ? (
-            // Granular over the page backstop: the thread list renders server
-            // data, and a bad row must cost the transient menu, not the page.
-            // Reopening the disclosure remounts it (historyOpen unmounts on
-            // close), which is what clears a latched card.
-            _jsx(SurfaceBoundary, { surface: "history-menu", children: _jsx(CompanionHistoryMenu, { id: historyMenuId, onClose: () => {
+                        }) })), _jsx(ConversationView, { core: core, surface: "page", suggestions: suggestions, welcomeTitle: welcomeTitle, welcomeMark: welcomeMark })] }), core.historyExpected && historyOpen ? (_jsx(SurfaceBoundary, { surface: "history-menu", children: _jsx(CompanionHistoryMenu, { id: historyMenuId, onClose: () => {
                         setHistoryOpen(false);
                     }, triggerRef: renderChrome === undefined ? historyTriggerRef : undefined, triggerId: renderChrome === undefined ? undefined : historyTriggerId, insetFromSurfaceTop: renderChrome !== undefined }) })) : null] }));
 }
-/** The history disclosure's flag, ids and the actions the chrome exposes;
- *  starting a fresh conversation takes the disclosure down with it. */
 function useHistoryDisclosure(core) {
     const [historyOpen, setHistoryOpen] = useState(false);
     const historyMenuId = useId();
@@ -105,36 +71,9 @@ function useHistoryDisclosure(core) {
 function SetupErrorSurface({ rootProps, frameless, setupError, }) {
     return (_jsx("div", { "data-tf-assistant": "", ...rootProps, className: cx("tf:flex tf:h-full tf:min-h-0 tf:w-full tf:items-center tf:justify-center tf:bg-tf-background tf:p-6", !frameless && "tf:rounded-tf tf:border"), children: _jsx(SetupErrorState, { message: setupError.message, code: setupError.code }) }));
 }
-/** The package's own header strip: the history disclosure (or a plain
- *  title for visitors with no history) and the new-conversation control. */
 function PageHeaderStrip({ title, historyExpected, historyMenuId, historyOpen, onHistoryOpenChange, historyTriggerRef, onNewConversation, }) {
     return (_jsxs("div", { className: "tf:flex tf:h-14 tf:shrink-0 tf:items-center tf:gap-1 tf:border-b tf:pr-2 tf:pl-4", children: [historyExpected ? (_jsx(CompanionHeaderTitle, { menuId: historyMenuId, open: historyOpen, onOpenChange: onHistoryOpenChange, triggerRef: historyTriggerRef, fallbackTitle: title })) : (_jsx("h2", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-heading tf:font-medium", children: title })), _jsx(TfButton, { variant: "icon", "aria-label": "New conversation", title: "New conversation", onClick: onNewConversation, children: _jsx(ComposeIcon, {}) })] }));
 }
-/**
- * Sends the host's opening message once, when this surface opens on an
- * empty conversation. Guarded on every reason a send would be wrong or
- * lost — a thread already exists, one is being opened, the setup failed,
- * the sign-in gate is up, or a send is already in flight — and latched by
- * a ref so a re-render can never send twice.
- *
- * The tier guard is what makes every other guard here mean anything. This
- * surface's effects run BEFORE its provider's (React commits a
- * descendant's first), and the provider's effect is where the session is
- * retained — which is what wires the identity resolver AND what bootstraps
- * the store. So on this effect's first pass nothing has happened yet: a
- * returning visitor's stored thread has not raised threadOpening, and an
- * identity-wired session has no registrant to ask for a vouch.
- *
- * Sending there does both harms at once. The mint goes out with nobody to
- * vouch, the session falls open to anonymous for its whole life, and the
- * thread this message creates belongs to a visitor the member never
- * becomes; meanwhile the stored thread resumes underneath and the greeting
- * has opened a second conversation over it.
- *
- * A non-null tier is the proof that bootstrap has run — the mint is its
- * first act — so waiting for one waits for the retain, whichever tier it
- * lands on and whether or not the host wired identity at all.
- */
 function useInitialPrompt(core, prompt) {
     const session = useOptionalAssistantSession();
     const gate = useCell(session?.conversationGate ?? NO_GATE_CELL);
@@ -166,4 +105,3 @@ function useInitialPrompt(core, prompt) {
         sendMessage,
     ]);
 }
-//# sourceMappingURL=assistant-page.js.map

package/dist/components/assistant-palette-body.d.ts

@@ -1,4 +1,3 @@
 export default function AssistantPaletteBody({ onOpenChange, }: {
     onOpenChange: (open: boolean) => void;
 }): import("react").JSX.Element;
-//# sourceMappingURL=assistant-palette-body.d.ts.map

package/dist/components/assistant-palette-body.js

@@ -5,27 +5,14 @@ import { ConversationView, SetupErrorState } from "./conversation-view.js";
 import { CloseIcon } from "./icons.js";
 import { TfButton } from "./primitives/button.js";
 import { useAssistantConversation } from "./use-assistant-conversation.js";
-// The palette's conversation half — the module that reaches the
-// transcript, loaded only through the palette's dynamic import (the
-// drawer-body precedent): a page whose palette is never opened never
-// downloads the chat. Mounted only while open: closing unmounts the
-// transcript (and with it the stream connection) — reopening replays.
-// Keeping it mounted would hold an invisible live SSE per closed
-// palette. Default export because React.lazy wants one.
 export default function AssistantPaletteBody({ onOpenChange, }) {
     const core = useAssistantConversation();
-    // Re-adopt the stored thread on every open (the body mounts per
-    // open): another surface (the page, another tab) may have moved the
-    // conversation while this one was closed, and opening the palette
-    // must mean "continue where I am".
     const resumeStoredThread = core.resumeStoredThread;
     useEffect(() => {
         resumeStoredThread();
     }, [resumeStoredThread]);
     return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:h-12 tf:shrink-0 tf:items-center tf:gap-1 tf:border-b tf:pr-2 tf:pl-4", children: [_jsx("h2", { className: "tf:flex-1 tf:text-tf-heading tf:font-medium", children: "Assistant" }), core.setupError === null ? (_jsx(TfButton, { variant: "ghost", onClick: (event) => {
                             core.startNewConversation();
-                            // A keyboard-first surface: the fresh conversation starts
-                            // with the caret in the composer, not on this button.
                             const dialog = event.currentTarget.closest("dialog");
                             requestAnimationFrame(() => {
                                 dialog
@@ -36,4 +23,3 @@ export default function AssistantPaletteBody({ onOpenChange, }) {
                             onOpenChange(false);
                         }, children: _jsx(CloseIcon, {}) })] }), core.setupError !== null ? (_jsx("div", { className: "tf:flex tf:flex-1 tf:items-center tf:justify-center tf:p-6", children: _jsx(SetupErrorState, { message: core.setupError.message, code: core.setupError.code }) })) : (_jsx(ConversationView, { core: core, surface: "palette" }))] }));
 }
-//# sourceMappingURL=assistant-palette-body.js.map

package/dist/components/assistant-palette.d.ts

@@ -2,14 +2,4 @@ export interface AssistantPaletteProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;
 }
-/**
- * The cmd-k overlay surface: the same conversation core as <AssistantPage/>
- * in a native-dialog shell — current/new thread only. Controlled: whoever
- * mounts it owns the trigger and open state; Esc and a backdrop click close
- * it from inside. Closing drops the live stream on purpose: reopening
- * remounts the transcript and the full replay-then-tail restores it exactly.
- * The export is the boundary; degrade="silent" because an in-flow fallback
- * card would land as a stray block on the host page.
- */
 export declare function AssistantPalette(props: AssistantPaletteProps): import("react").JSX.Element;
-//# sourceMappingURL=assistant-palette.d.ts.map