@teaflask/assistant 0.3.0 → 0.7.0

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

@@ -1,86 +1,84 @@
 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.
+ * The state and controls `renderChrome` receives, for drawing the full-page
+ * assistant's header controls in your own UI. The history menu itself is still
+ * rendered by the assistant.
  */
 export interface AssistantChrome {
+    /** The surface title from the `title` prop, `"Assistant"` by default. */
     title: string;
-    /** The active thread's title, falling back to the surface title. */
+    /**
+     * The open conversation's title, or the surface title when the conversation
+     * has none yet.
+     */
     conversationTitle: string;
-    /** False for anonymous visitors — there is no history to open. */
+    /**
+     * True when the user has a conversation history to open, meaning a
+     * signed-in user. False for anonymous visitors, so hide your history
+     * button.
+     */
     historyAvailable: boolean;
+    /** Whether the history menu is currently open. */
     historyOpen: boolean;
+    /**
+     * The element id of the history menu, for `aria-controls` on your history
+     * button.
+     */
     historyMenuId: string;
+    /**
+     * Put this id on your history button. Clicking it then doesn't count as
+     * clicking outside the menu, and Escape returns focus to it.
+     */
     historyTriggerId: string;
+    /** Opens the history menu. */
     openHistory: () => void;
+    /** Opens the history menu if it is closed and closes it if it is open. */
     toggleHistory: () => void;
+    /** Closes the history menu and starts a new, empty conversation. */
     newConversation: () => void;
 }
+/** Props for `AssistantPage`. */
 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.
+     * Removes the page's own border and rounded corners so it sits flush inside
+     * a frame you already draw. The default is false, which keeps the page as a
+     * self-contained card.
      */
     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.
+     * Opening prompts shown under the message box before the first message;
+     * clicking one sends it as the user's message. The full-page assistant
+     * shows none unless you pass them.
      */
     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.
+     * A message sent for the user as soon as the page opens on an empty
+     * conversation, for deep links or first-run flows. It is sent at most once
+     * per mount, never into an existing conversation and never while sign-in is
+     * required. Changing it later has no effect.
      */
     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.
+     * The heading above the empty message box, which defaults to `"Where should
+     * we begin?"`.
      */
     welcomeTitle?: string;
-    /** Optional host mark shown beside the empty-state invitation. */
+    /** Your own logo or artwork, shown beside the empty-state heading. */
     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".
-     */
+    /** The name shown in the page's header, which defaults to `"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.
+     * Replaces the page's built-in header with your own controls, built from
+     * the `AssistantChrome` it receives. Return a portal to put them in a bar
+     * you already have, in which case nothing renders in the header's place.
      */
     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.
+ * The full-page assistant: the conversation with a header, a history menu and a
+ * new-conversation button, filling the box you give it. Render it inside the
+ * provider or `TeaflaskAssistant`. It shares the same conversation as the other
+ * surfaces, and the corner widget hides while it is mounted.
  */
 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.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

@@ -1,15 +1,17 @@
+/** Props for `AssistantPalette`, which is controlled by its parent. */
 export interface AssistantPaletteProps {
+    /** Whether the palette is shown. */
     open: boolean;
+    /**
+     * Called with the new open state when the palette asks to open or close,
+     * for example on Escape or a backdrop click.
+     */
     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.
+ * The ⌘K palette: a centered dialog over your page showing the current
+ * conversation, with a way to start a new one. You control whether it is open,
+ * and Escape or a backdrop click closes it. `TeaflaskAssistant` already
+ * includes one, so render this yourself only alongside the provider.
  */
 export declare function AssistantPalette(props: AssistantPaletteProps): import("react").JSX.Element;
-//# sourceMappingURL=assistant-palette.d.ts.map

package/dist/components/assistant-palette.js

@@ -6,34 +6,15 @@ import { LazyBody } from "./lazy-body.js";
 import { SurfaceBoundary } from "./surface-boundary.js";
 import { TfDialog } from "./primitives/dialog.js";
 import { useRegisterAssistantSurface } from "./use-register-assistant-surface.js";
-// The body is code-split behind the first open, so mounting a closed
-// palette on every page ships no transcript (the bundle discipline).
 const AssistantPaletteBody = lazy(() => import("./assistant-palette-body.js"));
-/**
- * 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 function AssistantPalette(props) {
     return (_jsx(SurfaceBoundary, { surface: "palette", degrade: "silent", children: _jsx(AssistantPaletteInner, { ...props }) }));
 }
 function AssistantPaletteInner({ open, onOpenChange }) {
-    // The provider's theme/mode props ride onto every data-tf-assistant root.
     const { rootProps } = useAssistantAppearance();
-    // Announced only while open: the dialog root stays mounted while closed
-    // (rendering nothing), and a closed palette must not read as an active surface.
     useRegisterAssistantSurface("transient", open);
-    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "aria-label": "Assistant", "data-tf-assistant": "", "data-tf-glass": "", "data-tf-assistant-palette": "", ...rootProps, className: 
-        // Mobile: a near-full-screen sheet with a 4-step margin. Desktop: the
-        // cmd-k idiom — top-anchored, centered, fixed height. The scrim is 20%,
-        // not a classic 40%: the glass blurs its own backdrop; a heavy dim curdles it.
-        "tf:m-auto tf:h-[calc(100dvh-2rem)] tf:w-[calc(100vw-2rem)] tf:flex-col " +
+    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "aria-label": "Assistant", "data-tf-assistant": "", "data-tf-glass": "", "data-tf-popover": "", "data-tf-assistant-palette": "", ...rootProps, className: "tf:m-auto tf:h-[calc(100dvh-2rem)] tf:w-[calc(100vw-2rem)] tf:flex-col " +
             "tf:overflow-hidden tf:rounded-tf tf:border " +
-            "tf:text-tf-foreground tf:backdrop:bg-black/20 " +
+            "tf:backdrop:bg-black/20 " +
             "tf:sm:mt-24 tf:sm:h-[calc(100dvh-12rem)] tf:sm:max-h-144 tf:sm:w-full tf:sm:max-w-2xl", children: open ? (_jsx(LazyBody, { children: _jsx(AssistantPaletteBody, { onOpenChange: onOpenChange }) })) : null }));
 }
-//# sourceMappingURL=assistant-palette.js.map

package/dist/components/assistant-transcript.js

@@ -14,9 +14,6 @@ import { MessageList, } from "./message-list.js";
 import { HostSlotBoundary } from "./slot-boundary.js";
 import { useLatestRef } from "./use-latest-ref.js";
 export function AssistantTranscript(props) {
-    // Two internal components so each mode's hook list stays static;
-    // switching source kinds remounts, which is the honest lifecycle (an
-    // agent-mode mount owns a connection the rows mode never opened).
     if (props.agent !== undefined) {
         return _jsx(AgentModeTranscript, { ...props });
     }
@@ -25,62 +22,22 @@ export function AssistantTranscript(props) {
 const EMPTY_SNAPSHOT = { messages: [], running: false };
 const NO_CARDS = [];
 const NO_IDS = new Set();
-// The anchor families this surface has no recorder for (the ./transcript
-// entry's scope note): passable empty by design — absent facts degrade
-// the rows honestly (no timing → "Worked", no memory attribution → no
-// footer), never crash.
 const NO_MAP = new Map();
-/** A recorder callback that folds its arguments into an anchor map:
- *  `setter(previous => merge(previous, ...args))`, typed once for the
- *  five anchor families the transcript records. */
 function anchorInto(setter, merge) {
     return (...args) => {
         setter((previous) => merge(previous, ...args));
     };
 }
-/** The connection agent mode owns — recorders subscribed before connect,
- *  unsubscribe-then-abort on teardown — and the snapshot and anchor maps
- *  those recorders publish. */
 function useAgentRecording(agent, onStreamError) {
-    // Null until the recorder publishes its first snapshot — even an empty
-    // settled log delivers one (the synthesized RUN_STARTED), so null means
-    // exactly "still connecting" and gates the welcome screen.
     const [snapshot, setSnapshot] = useState(null);
-    // Anchor maps for wire facts the message list does not carry as such:
-    // backend-authored display copy rides CUSTOM markers, never a message,
-    // and the tool-outcome extras reach agent.messages only as lifted
-    // metadata (core/tool-outcome.ts) — the recorders keep these maps as the
-    // read path, stable across remounts. First-wins merges return the
-    // previous map by identity on replayed re-delivery, so StrictMode reruns
-    // and reconnect replays no-op these setStates.
     const [displayAnchors, setDisplayAnchors] = useState(EMPTY_TOOL_CALL_DISPLAY_ANCHORS);
     const [errorAnchors, setErrorAnchors] = useState(EMPTY_TOOL_ERROR_ANCHORS);
     const [cancelAnchors, setCancelAnchors] = useState(EMPTY_TOOL_CANCEL_ANCHORS);
-    // The offload stamp: an offloaded result's content is the offloader's
-    // model-facing replacement, not the tool's output — without this set
-    // the row would render that replacement as if the tool had said it.
     const [offloadAnchors, setOffloadAnchors] = useState(EMPTY_TOOL_OFFLOAD_ANCHORS);
-    // The refusal signal: a door that answered and declined stamps
-    // `refused` (a sentence) INSTEAD of `error`, so a surface reading only
-    // `error` would render the refusal as a clean success whose Result pane
-    // shows the refusal envelope — and group a refused dispatch as a
-    // coworker that ran.
     const [refusalAnchors, setRefusalAnchors] = useState(EMPTY_TOOL_REFUSAL_ANCHORS);
-    // The denial ledger: a member's denial reaches the wire as a
-    // `cancelled` result, so a surface reading only the cancel stamp
-    // renders it "Interrupted". The ledger joins approval_requested to
-    // approval_resolved{approved:false} by interrupt id; only its DENIED
-    // half reaches the snapshot, and the fold returns the same object when
-    // nothing changed, so replays no-op this setState too.
     const [denialLedger, setDenialLedger] = useState(EMPTY_TOOL_DENIAL_LEDGER);
-    // The error tap rides a ref so a host handing a fresh closure per
-    // render never tears the connection down and replays it.
     const streamErrorRef = useLatestRef(onStreamError);
     useEffect(() => {
-        // Subscribe before connect: the recorders must see the replay's
-        // first event. Sibling recorder components (markers, approvals)
-        // render before this component in the hosts, so their effects — and
-        // therefore their subscriptions — run earlier still.
         const taps = [
             agent.subscribe(messagesSnapshotRecorder(setSnapshot)),
             agent.subscribe(connectionErrorRecorder((error) => {
@@ -93,13 +50,8 @@ function useAgentRecording(agent, onStreamError) {
             agent.subscribe(toolRefusalRecorder(anchorInto(setRefusalAnchors, withToolRefusalAnchored))),
             agent.subscribe(toolDenialRecorder(anchorInto(setDenialLedger, withToolDenialMarkerFolded))),
         ];
-        // The recorder carries connection failures (onRunFailed); the
-        // rejection here would only duplicate it.
         agent.connectAgent().catch(() => undefined);
         return () => {
-            // Unsubscribe BEFORE aborting: the teardown's own synthesized
-            // abort RUN_ERROR must never reach the error tap or repaint the
-            // message state.
             for (const tap of taps) {
                 tap.unsubscribe();
             }
@@ -120,29 +72,12 @@ function useAgentRecording(agent, onStreamError) {
 function AgentModeTranscript({ agent, onStreamError, markers, markerBoundaries, resumeAnchoredIds = NO_IDS, deliveryAnchoredIds = NO_IDS, turnAttachments, frameClaimsLiveness, scrollClassName, messageView, toolRow, input, welcomeScreen, threadList, }) {
     const { snapshot, displayAnchors, errorAnchors, cancelAnchors, offloadAnchors, refusalAnchors, denialLedger, } = useAgentRecording(agent, onStreamError);
     const delivered = snapshot ?? EMPTY_SNAPSHOT;
-    // Where each declared value lands is enumerated in
-    // docs/transcript-surfaces.md, "The agent binder's declared values".
-    // The arms easiest to get wrong: deliveryAnchoredIds feeds BOTH the
-    // severance scan (presence-based) and MessageList's turnStartIds (the
-    // fold pass is ROW-based, so the empty arrays do not suffice);
-    // turnAttachments → transcriptBlocksOf's side-table join only;
-    // scrollClassName, the five slots → render only.
     const anchors = useMemo(() => ({
-        // Presence drives the severance window; the payload is the host's
-        // marker state, not the projection's to read.
         resumeAnchors: new Map([...resumeAnchoredIds].map((id) => [id, null])),
-        // Empty on purpose: a boundary without a row — the host's own
-        // marker draws the divider, so a projected one would double it (the
-        // row guard is `results.length > 0`). Every consumer that must see
-        // the delivery boundary reads the anchor MAP's keys or an explicit
-        // id set (the severance scan, the turnStartIds below); only the
-        // divider ROW rides the array length — the one thing suppressed.
         subagentDeliveryAnchors: new Map([...deliveryAnchoredIds].map((id) => [id, []])),
         toolErrorAnchors: errorAnchors,
         toolCancelAnchors: cancelAnchors,
         toolRefusalAnchors: refusalAnchors,
-        // The ledger's presentation half only; the ask map stays
-        // in the fold's own state.
         toolDenialAnchors: denialLedger.denied,
         toolCallDisplayAnchors: displayAnchors,
         turnFailedAnchors: NO_MAP,
@@ -162,23 +97,13 @@ function AgentModeTranscript({ agent, onStreamError, markers, markerBoundaries,
         denialLedger.denied,
         displayAnchors,
     ]);
-    // Memoized on the snapshot AND the marker boundaries: marker positions
-    // are part of the block derivation (they split delegation groups), so
-    // a newly anchored marker legitimately re-runs the dedupe — a rare
-    // event, anchors move a handful of times per run.
     const blocks = useMemo(() => transcriptBlocksOf(delivered.messages, anchors, delivered.running, undefined, {
         markerBoundaries,
         attachmentsByMessageId: turnAttachments,
     }), [delivered, anchors, markerBoundaries, turnAttachments]);
     const showWelcome = _welcomeMomentOf(snapshot, blocks.length, welcomeScreen);
-    return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { blocks: blocks, cards: NO_CARDS, turnStartIds: deliveryAnchoredIds, 
-            // The dashboard wire has no turn-status cell: the snapshot's
-            // running bit is this surface's one liveness fact, so it carries
-            // both the live register and the open-tail fold regime.
-            live: delivered.running, turnOpen: delivered.running, markers: markers, markerBoundaries: markerBoundaries, frameClaimsLiveness: frameClaimsLiveness, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
+    return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { blocks: blocks, cards: NO_CARDS, turnStartIds: deliveryAnchoredIds, live: delivered.running, turnOpen: delivered.running, markers: markers, markerBoundaries: markerBoundaries, frameClaimsLiveness: frameClaimsLiveness, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
 }
-/** The welcome screen's moment: a connected, genuinely empty log with a
- *  host welcome to show (agent mode waits for the first snapshot). */
 function _welcomeMomentOf(snapshot, blockCount, welcomeScreen) {
     return (snapshot !== null && blockCount === 0 && !hostFillDeclines(welcomeScreen));
 }
@@ -186,15 +111,6 @@ function RowsModeTranscript({ rows, cards = NO_CARDS, live, turnOpen, decisionSu
     const showWelcome = rows.length === 0 && !hostFillDeclines(welcomeScreen);
     return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { rows: rows, cards: cards, live: live, turnOpen: turnOpen, decisionSurfacesInShelf: decisionSurfacesInShelf, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
 }
-/** The frame — a fragment, never a box: chrome above the log inside its
- *  slot boundary, the input region below it deliberately unbounded (the
- *  input-region rule above — a throw propagates to the host's own
- *  boundary), each absent from the DOM entirely when unfilled. */
 function TranscriptFrame({ threadList, input, children, }) {
-    return (_jsxs(_Fragment, { children: [!hostFillDeclines(threadList) ? (
-            // The chrome hook div rides INSIDE the boundary (the keying law): it
-            // exists to be host-styled, so a latched-away fill takes it along
-            // rather than leave an empty strip wearing the host's padding.
-            _jsx(HostSlotBoundary, { slot: "threadList", fallback: null, children: _jsx("div", { "data-tf-transcript-chrome": "", children: threadList }) })) : null, children, input ?? null] }));
+    return (_jsxs(_Fragment, { children: [!hostFillDeclines(threadList) ? (_jsx(HostSlotBoundary, { slot: "threadList", fallback: null, children: _jsx("div", { "data-tf-transcript-chrome": "", children: threadList }) })) : null, children, input ?? null] }));
 }
-//# sourceMappingURL=assistant-transcript.js.map

package/dist/components/attachment-chips.js

@@ -4,12 +4,6 @@ import { useEffect, useState } from "react";
 import { humanFileSize } from "./human-file-size.js";
 import { FileIcon } from "./icons.js";
 import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
-// A user message's attachments, the quiet register: images render inline
-// (an inset hairline contains uncontrolled customer imagery on any
-// ground — the org-logo law), everything else is a small muted chip
-// naming the file. Bytes are a download-url exchange away: the id is
-// stable, a URL is minted on mount and re-minted as it expires — a
-// widget stays open far longer than a URL lives, and nothing persists.
 export function AttachmentChips({ attachments, }) {
     if (attachments.length === 0) {
         return null;
@@ -19,9 +13,6 @@ export function AttachmentChips({ attachments, }) {
 function AttachmentImage({ attachment }) {
     const url = useAttachmentUrl(attachment.id);
     if (url === null) {
-        // The mint is in flight (or refused — a swept upload): the chip is
-        // the truthful fallback either way, and the image swaps in if the
-        // URL lands.
         return _jsx(FileChip, { attachment: attachment });
     }
     return (_jsx("img", { src: url, alt: attachment.filename, loading: "lazy", className: "tf:max-h-48 tf:max-w-full tf:rounded-lg tf:ring-1 tf:ring-tf-border tf:ring-inset" }));
@@ -31,10 +22,6 @@ function FileChip({ attachment }) {
             "tf:bg-tf-background tf:px-2.5 tf:py-1.5 tf:text-xs tf:text-tf-foreground " +
             "tf:ring-1 tf:ring-tf-border tf:ring-inset", title: attachment.filename, children: [_jsx("span", { className: "tf:text-tf-muted-foreground", children: _jsx(FileIcon, {}) }), _jsx("span", { className: "tf:min-w-0 tf:truncate", children: attachment.filename }), _jsx("span", { className: "tf:shrink-0 tf:text-tf-muted-foreground", children: humanFileSize(attachment.byte_size) })] }));
 }
-// The fastest the hook ever goes back to the mint endpoint: the retry
-// delay after a blipped refresh, and the floor under the expiry timer —
-// a served TTL at or under the store's safety margin puts the expiry in
-// the past, which must slow the cadence, never become a tight loop.
 const URL_REFRESH_FLOOR_MS = 30_000;
 function useAttachmentUrl(attachmentId) {
     const session = useOptionalAssistantSession();
@@ -52,9 +39,6 @@ function useAttachmentUrl(attachmentId) {
                     return;
                 }
                 setUrl(minted.url);
-                // The URL dies at its short TTL while this mount may live for
-                // hours: re-mint as the expiry lands, so a lazy <img> that
-                // fetches late never holds an expired URL.
                 timer = setTimeout(() => {
                     mintAndScheduleRefresh(true);
                 }, Math.max(URL_REFRESH_FLOOR_MS, minted.expiresAtMs - Date.now()));
@@ -62,10 +46,6 @@ function useAttachmentUrl(attachmentId) {
                 if (cancelled) {
                     return;
                 }
-                // A refused first mint (a swept upload) keeps the chip
-                // fallback — decoration never surfaces an error. A refused
-                // refresh is a blip on a URL that already worked: try again,
-                // or the image freezes on an expired URL.
                 if (isRefresh) {
                     timer = setTimeout(() => {
                         mintAndScheduleRefresh(true);
@@ -81,4 +61,3 @@ function useAttachmentUrl(attachmentId) {
     }, [store, attachmentId]);
     return url;
 }
-//# sourceMappingURL=attachment-chips.js.map