@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/composer.js

@@ -1,10 +1,9 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useLayoutEffect, useRef, useState, } from "react";
-import { ASSISTANT_MAX_ATTACHMENTS, ASSISTANT_MESSAGE_MAX_CHARS, } from "../contract/threads.js";
-import { humanFileSize } from "./human-file-size.js";
+import { ASSISTANT_MESSAGE_MAX_CHARS, } from "../contract/threads.js";
 import { attachmentAcceptOf, ComposerAttachmentChip, } from "./composer-attachment-chip.js";
-import { ConversationGateCard } from "./conversation-gate-card.js";
+import { ComposerBanner } from "./composer-banner.js";
 import { useConversation } from "./conversation-context.js";
 import { ArrowUpIcon, PlusIcon, StopIcon } from "./icons.js";
 import { TfButton } from "./primitives/button.js";
@@ -13,48 +12,18 @@ import { TfTextarea } from "./primitives/textarea.js";
 import { ModelPickerShelf } from "./model-picker-chip.js";
 import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
 import { NO_GATE } from "../core/connect-gate.js";
-import { attachmentDraftFailed, capSlotsSpentBy, CHARACTER_COUNT_VISIBLE_FROM, composerKeyHandlersOf, mintAttachmentDraftId, pickCapOf, } from "../core/composer-policy.js";
+import { attachmentRoomOf } from "../core/composer-attachments.js";
+import { attachmentDraftFailed, capSlotsSpentBy, CHARACTER_COUNT_VISIBLE_FROM, composerKeyHandlersOf, } from "../core/composer-policy.js";
 import { ObservableCell } from "../core/observable-cell.js";
 import { useCell } from "./use-store-cell.js";
-// The composer's no-provider fallback (welcome-branch tests render the
-// view bare): a frozen null cell, so the hook order never bends.
 const NO_POLICY = new ObservableCell(null);
 const NO_GATE_CELL = new ObservableCell(NO_GATE);
-// The autosize cap: ~8 lines of the 15px/1.6 body step; past this the
-// draft scrolls inside the box instead of swallowing the transcript.
 const COMPOSER_MAX_HEIGHT_PX = 200;
-/**
- * The message composer. Sending is the contract's message POST, wired in
- * by context (never the stream — the watch-only stream cannot create a
- * turn). The maxLength mirrors the send surface's bound so the limit is
- * felt while typing, not as a 422 after submitting. Attachments ride the
- * served policy: no policy, no paperclip.
- *
- * `surface` is the caret-return handoff's identity: several
- * surfaces render this composer over ONE store, and a reconnect-nonce
- * bump remounts all of them in one commit — the store's focus record
- * and the owed caret return are stamped with the owning surface so only
- * the matching fresh instance consumes the return. PREMISE: surface
- * names are unique per mounted view — the transcript lease already
- * keys its holder list on the same strings.
- */
 export function Composer({ compact = false, surface = "page", }) {
-    const { busy, pendingSend, sendMessage, composerRefocusPending, markComposerRefocusHandled, stopping, stopTurn, 
-    // The unsaved draft and its staged attachments are the STORE's
-    // truth, not instance state: this component remounts with the keyed
-    // transcript on every reconnect-nonce move — a send, a retry, a
-    // stream death under the same turn — and unsaved input must never
-    // die with an instance. They arrive on a dedicated cell, not on
-    // this contract snapshot, so a keystroke re-renders THIS component
-    // alone — never the transcript reading the same context.
-    composerInput, setDraft, setAttachments, noteComposerFocus, takeComposerCaretReturn, } = useConversation();
+    const { busy, pendingSend, sendMessage, composerRefocusPending, markComposerRefocusHandled, stopping, stopTurn, composerInput, setDraft, setAttachments, addFiles, noteComposerFocus, takeComposerCaretReturn, } = useConversation();
     const { draft, attachments } = useCell(composerInput);
     const session = useOptionalAssistantSession();
     const policy = useCell(session?.attachmentPolicy ?? NO_POLICY);
-    // The conversation gate: when the next send cannot serve without the
-    // visitor acting, the gate card takes the slab's place. This
-    // component stays mounted either way, so the draft survives the gate
-    // and returns with the composer.
     const gate = useCell(session?.conversationGate ?? NO_GATE_CELL);
     const send = useComposerSend({
         busy,
@@ -68,7 +37,7 @@ export function Composer({ compact = false, surface = "page", }) {
     const attach = useComposerAttachments({
         session,
         policy,
-        attachments,
+        addFiles,
         setAttachments,
     });
     const { textareaRef, onTextareaFocus, onTextareaBlur } = useComposerFocus({
@@ -80,25 +49,10 @@ export function Composer({ compact = false, surface = "page", }) {
         noteComposerFocus,
         takeComposerCaretReturn,
     });
-    return (
-    // The live composer repeats the transcript's max-w-3xl measure. The
-    // empty page asks for the compact edition: before there is a
-    // transcript, a broad input reads as an empty panel rather than a
-    // deliberate starting point.
-    _jsx("div", { "data-tf-composer-root": "", "data-tf-composer-ground": "", className: "tf:relative tf:bg-tf-background tf:pt-1 tf:pb-4", children: _jsxs("div", { className: "tf:mx-auto tf:w-full tf:px-4 " +
-                (compact ? "tf:max-w-xl" : "tf:max-w-3xl"), children: [gate.kind === "connect" ||
-                    gate.kind === "wait" ||
-                    gate.kind === "verifying" ? (_jsx(ConversationGateCard, { gate: gate })) : null, _jsx(ComposerSlabAndShelf, { draft: draft, setDraft: setDraft, attachments: attachments, policy: policy, gate: gate, busy: busy, pendingSend: pendingSend, stopping: stopping, stopTurn: stopTurn, send: send, attach: attach, textareaRef: textareaRef, onTextareaFocus: onTextareaFocus, onTextareaBlur: onTextareaBlur })] }) }));
+    return (_jsx("div", { "data-tf-composer-root": "", "data-tf-composer-ground": "", className: "tf:relative tf:bg-tf-background tf:pt-1 tf:pb-4", children: _jsxs("div", { className: "tf:mx-auto tf:w-full tf:px-4 " +
+                (compact ? "tf:max-w-xl" : "tf:max-w-3xl"), children: [_jsx(ComposerBanner, { gate: gate }), _jsx(ComposerSlabAndShelf, { draft: draft, setDraft: setDraft, attachments: attachments, policy: policy, gate: gate, busy: busy, pendingSend: pendingSend, stopping: stopping, stopTurn: stopTurn, send: send, attach: attach, textareaRef: textareaRef, onTextareaFocus: onTextareaFocus, onTextareaBlur: onTextareaBlur })] }) }));
 }
-// This instance's send: the disabled verdict over the draft and its
-// staged attachments, and the submit that clears optimistically and
-// restores on refusal.
 function useComposerSend({ busy, draft, attachments, composerInput, sendMessage, setDraft, setAttachments, }) {
-    // Ruled instance-LOCAL: `sending` mirrors this instance's own
-    // in-flight submitDraft promise; the cross-instance truth every
-    // surface reads is the store's pendingSend. No remount fires while it
-    // is meaningfully true — a send is only submittable when not busy,
-    // and the death arm's reconnect exists only over a working turn.
     const [sending, setSending] = useState(false);
     const trimmedDraft = draft.trim();
     const readyAttachments = attachments.flatMap((item) => item.status === "ready" && item.attachment !== undefined
@@ -123,25 +77,7 @@ function useComposerSend({ busy, draft, attachments, composerInput, sendMessage,
             byte_size: attachment.byte_size,
         }));
         setSending(true);
-        // Captured before the await: the refusal restore below may only
-        // write into the conversation this send belonged to. The setters are
-        // the STORE's stable arrows now, so this continuation outlives the
-        // composer instance — without the scope check, a thread switch or
-        // New conversation mid-POST followed by a refusal would leak this
-        // thread's text and attachment ids into the conversation that
-        // replaced it. PREMISE the guard rests on: every distinct
-        // conversation-context has a distinct scope — thread-backed ones by
-        // their immutable, never-reused server id, conversation-LESS states
-        // by a token minted fresh on every reset (null was shared by every
-        // empty state, so a first send refused after New conversation leaked
-        // back in) — and the scope tracks every _active move (the
-        // ComposerInput invariant). An equal scope at settle time therefore
-        // means the restore lands in the very conversation the text was
-        // typed in, even if the visitor left and came back meanwhile.
         const submittedScope = composerInput.get().scope;
-        // The conversation moves immediately: the store paints an optimistic
-        // user bubble while the input clears for the next thought. A refusal
-        // restores exactly what was attempted below.
         const landing = sendMessage(submittedDraft, readyIds, optimisticAttachments);
         setDraft("");
         setAttachments([]);
@@ -160,134 +96,25 @@ function useComposerSend({ busy, draft, attachments, composerInput, sendMessage,
     }
     return { sending, sendDisabled, submitDraft };
 }
-// The paperclip's side of the slab: the served policy's cap, the pick
-// that stages uploads (and lands rejections as failed chips), removal.
-function useComposerAttachments({ session, policy, attachments, setAttachments, }) {
-    // The policy rides the config fetch; kick it so the paperclip appears
-    // without waiting for a surface that renders suggestions to ask first.
+function useComposerAttachments({ session, policy, addFiles, setAttachments, }) {
     useEffect(() => {
         session?.ensureAssistantConfig();
     }, [session]);
-    function addFiles(files) {
-        if (files === null || policy === null || session === null) {
-            return;
-        }
-        const { store } = session;
-        const room = Math.min(policy.max_per_message, ASSISTANT_MAX_ATTACHMENTS);
-        let taken = capSlotsSpentBy(attachments);
-        for (const file of Array.from(files)) {
-            const localId = mintAttachmentDraftId();
-            const entry = {
-                localId,
-                filename: file.name !== "" ? file.name : "attachment",
-                byteSize: file.size,
-                status: "uploading",
-            };
-            // A pick past the cap lands as a failed chip, never a silent drop —
-            // the visitor must not believe twelve files ride when ten do.
-            if (taken >= room) {
-                setAttachments((current) => [
-                    ...current,
-                    {
-                        ...entry,
-                        status: "failed",
-                        error: `Too many files — the limit is ${String(room)} per message.`,
-                    },
-                ]);
-                continue;
-            }
-            // The per-kind truth lands at finalize (the server sniffs the
-            // bytes), but the browser's MIME type is a confident-enough guess
-            // to feel the RIGHT kind's cap at pick time — a 6MB photo must
-            // hear "5 MB", not the 32MB document ceiling. Unknown types get
-            // the widest cap; the sniff stays the truth.
-            const cap = pickCapOf(file, policy.max_bytes_by_kind);
-            if (file.size > cap.bytes) {
-                setAttachments((current) => [
-                    ...current,
-                    {
-                        ...entry,
-                        status: "failed",
-                        error: `Too large — the limit for ${cap.label} is ${humanFileSize(cap.bytes)}.`,
-                    },
-                ]);
-                continue;
-            }
-            // Only a file that actually becomes an upload draft spends a cap
-            // slot — a rejected pick must not crowd out a valid one behind it.
-            taken += 1;
-            setAttachments((current) => [...current, entry]);
-            // These continuations outlive the instance (the setters are store
-            // arrows) yet need NO conversation-scope guard, unlike the
-            // send-refusal restore: they only TRANSFORM the entry whose localId
-            // they captured, never add one. A thread switch or abandon clears
-            // the store's list, the localId no longer matches, and the settle
-            // maps over the list without touching anything. PREMISE: localIds
-            // come from a module counter that only counts up, so an id removed
-            // by a clear can never reappear and match a stale settle.
-            store.uploadAttachment(file).then((settled) => {
-                setAttachments((current) => current.map((item) => item.localId === localId
-                    ? { ...item, status: "ready", attachment: settled }
-                    : item));
-            }, (error) => {
-                setAttachments((current) => current.map((item) => item.localId === localId
-                    ? {
-                        ...item,
-                        status: "failed",
-                        error: error instanceof Error
-                            ? error.message
-                            : "The upload failed.",
-                    }
-                    : item));
-            });
+    function pickFiles(files) {
+        if (files !== null) {
+            void addFiles(files);
         }
     }
     function removeAttachment(localId) {
-        // Local removal only: an uploaded-but-never-sent object is the
-        // server's unclaimed sweep's to reclaim.
         setAttachments((current) => current.filter((item) => item.localId !== localId));
     }
-    const attachmentRoom = policy === null
-        ? 0
-        : Math.min(policy.max_per_message, ASSISTANT_MAX_ATTACHMENTS);
-    return { attachmentRoom, addFiles, removeAttachment };
+    const attachmentRoom = policy === null ? 0 : attachmentRoomOf(policy);
+    return { attachmentRoom, addFiles: pickFiles, removeAttachment };
 }
-// The textarea's focus choreography and autosize: the store's focus
-// record dies with its owner, the caret returns after a send or a
-// death-arm remount, and the box grows with the draft to a cap.
 function useComposerFocus({ surface, draft, busy, composerRefocusPending, markComposerRefocusHandled, noteComposerFocus, takeComposerCaretReturn, }) {
     const textareaRef = useRef(null);
-    // Whether THIS instance's textarea owns focus, per its own events —
-    // the scope that lets the unmount cleanup below invalidate the
-    // store's record without a bystander instance (page vs palette)
-    // clobbering an owner's record.
     const ownsFocusRef = useRef(false);
-    // THE RECORD DIES WITH ITS OWNER — AND ONLY WITH ITS OWNER: the store's
-    // focus record is written by focus/blur events, but an element can also
-    // go away with NO event at all — the death-arm remount, the
-    // thread-switch skeleton swap, a palette close, a surface teardown all
-    // remove a possibly-focused textarea without firing blur. Left
-    // uncleared, the record reads stale and the NEXT stream death steals
-    // focus into a composer nobody touched (the facet-ii hazard). So the
-    // owning instance invalidates it on unmount. The DOM check is
-    // load-bearing: React's dev-time StrictMode fires this same cleanup on
-    // a SIMULATED unmount — the element stays mounted and focused — and a
-    // ref-only guard cleared a record the caret still backed, disarming
-    // every death-arm return after the first. Checking "is the caret still
-    // in this box?" makes the replay a no-op, while a real unmount always
-    // fails the check (the node is detached, so activeElement has fallen
-    // elsewhere) and the invalidation still lands where it must. ORDERING
-    // PREMISE (verified at the death arm): the arm reads the record
-    // synchronously BEFORE the publishStore() whose remount unmounts this
-    // instance, so this cleanup runs strictly after the arming decision and
-    // can never disarm a legitimate caret return — and the fresh instance's
-    // own focus() re-records the owner through the ordinary onFocus path.
     useEffect(() => {
-        // Captured at setup, not read from the ref in the cleanup: React
-        // detaches refs around unmounts (real AND simulated), so a ref read
-        // inside the cleanup can be null while the node itself still stands
-        // — the captured node is the stable identity to test the caret
-        // against.
         const box = textareaRef.current;
         return () => {
             if (ownsFocusRef.current && document.activeElement !== box) {
@@ -295,10 +122,6 @@ function useComposerFocus({ surface, draft, busy, composerRefocusPending, markCo
             }
         };
     }, [noteComposerFocus]);
-    // Every send remounts the transcript (the reconnect story) and this
-    // composer with it, which drops keyboard focus on the floor; once the
-    // send settles, put the caret back — unless the visitor moved focus
-    // somewhere deliberate meanwhile.
     useEffect(() => {
         if (busy || !composerRefocusPending) {
             return;
@@ -308,57 +131,23 @@ function useComposerFocus({ surface, draft, busy, composerRefocusPending, markCo
             textareaRef.current?.focus();
         }
     }, [busy, composerRefocusPending, markComposerRefocusHandled]);
-    // The death arm's remount hands the caret back AT THE REMOUNT: the
-    // turn is still live and this box stays enabled, so the settle-gated
-    // effect above would leave the visitor typing into <body> for the rest
-    // of the answer. Runs once per instance on purpose (the arrow is a
-    // stable store property); the store arms it ONLY when a composer
-    // demonstrably owned focus, and the take consumes ONLY on the surface
-    // that owned it — every keyed transcript remounts on one bump, and an
-    // unscoped take let a bystander surface's composer burn the one-shot
-    // in tree order while the owner got false. The owner then delivers or
-    // forfeits in the same breath: its dropped-focus guard covers both
-    // resting places of a torn-down caret (body on a plain page, the
-    // dialog element inside the modal palette), and if the visitor parked
-    // focus somewhere deliberate meanwhile, forfeiting is correct — the
-    // moment has passed.
     useEffect(() => {
         if (takeComposerCaretReturn(surface) &&
             _focusWasDroppedByTheRemount(textareaRef.current)) {
             textareaRef.current?.focus();
         }
     }, [takeComposerCaretReturn, surface]);
-    // Autosize: the box starts at two lines and grows with the draft to a
-    // cap, then scrolls inside — a fixed two-line box decapitates the first
-    // line of any longer question. Layout-effect timing keeps the height in
-    // step with the very keystroke that changed it.
     useLayoutEffect(() => {
         const textarea = textareaRef.current;
         if (textarea === null) {
             return;
         }
         textarea.style.height = "auto";
-        // Zero means unrendered, not empty: the palette mounts this inside a
-        // <dialog> that is still display:none (showModal() runs in a later
-        // passive effect), and pinning 0px would override the rows floor
-        // with a collapsed sliver until the first keystroke re-measures.
         if (textarea.scrollHeight === 0) {
             return;
         }
         textarea.style.height = `${String(Math.min(textarea.scrollHeight, COMPOSER_MAX_HEIGHT_PX))}px`;
     }, [draft]);
-    // The store's focus record: this surface's name between a
-    // real focus and the matching blur. HOW THE CARET LEAVES
-    // this box, exhaustively: (1) focus MOVES — blur fires, the
-    // record clears here; (2) the element UNMOUNTS — no blur
-    // fires (DOM spec), and the owner's unmount cleanup above
-    // clears the record instead, except across the death arm's
-    // own remount, where the arm already read the record before
-    // the unmount and the fresh instance's focus() re-records
-    // the owner; (3) dev-time StrictMode REPLAYS that cleanup
-    // without any unmount — its DOM check makes the replay a
-    // no-op. The death arm reads the record to decide whether —
-    // and for which surface — a caret return is owed.
     return {
         textareaRef,
         onTextareaFocus: () => {
@@ -371,17 +160,7 @@ function useComposerFocus({ surface, draft, busy, composerRefocusPending, markCo
         },
     };
 }
-// The slab and its shelf, named as one unit. A module-level component,
-// never a closure nested in Composer: a nested component's identity
-// would change every render and remount the textarea mid-keystroke.
 function ComposerSlabAndShelf({ draft, setDraft, attachments, policy, gate, busy, pendingSend, stopping, stopTurn, send, attach, textareaRef, onTextareaFocus, onTextareaBlur, }) {
-    // Enter submits, Escape stops — the composer policy leaf's verbs
-    // (shared with the dashboard playground). Escape's preventDefault
-    // suppresses the palette dialog's native cancel and the drawer's
-    // Esc-to-close (both yield to defaultPrevented), so Escape mid-answer
-    // stops the turn without closing the surface — and Escape while idle,
-    // or in either no-op window, still closes it exactly as before. Bound
-    // on the textarea and the stop button, never a wrapper.
     const { stopOnEscape, composerKeys } = composerKeyHandlersOf({
         busy,
         pendingSend,
@@ -393,50 +172,25 @@ function ComposerSlabAndShelf({ draft, setDraft, attachments, policy, gate, busy
                     "tf:transition-[border-color,box-shadow] " +
                     "tf:focus-within:border-tf-foreground/25", children: [attachments.length > 0 ? (_jsx("div", { className: "tf:flex tf:flex-wrap tf:gap-1.5 tf:px-1 tf:pt-1 tf:pb-2", children: attachments.map((item) => (_jsx(ComposerAttachmentChip, { item: item, onRemove: () => {
                                 attach.removeAttachment(item.localId);
-                            } }, item.localId))) })) : null, _jsx(TfTextarea, { ref: textareaRef, rows: 2, variant: "bare", "data-tf-autofocus": "", value: draft, maxLength: ASSISTANT_MESSAGE_MAX_CHARS, 
-                        // "Send a message" labels a control; this invites one. Short
-                        // enough that a 390px column still shows all of it. Constant
-                        // on purpose: the placeholder describes the input, never the
-                        // run — a busy variant narrated run state and could
-                        // contradict the rest of the surface mid-pause.
-                        placeholder: "Ask anything", "aria-label": "Message", onChange: (event) => {
+                            } }, item.localId))) })) : null, _jsx(TfTextarea, { ref: textareaRef, rows: 2, variant: "bare", "data-tf-autofocus": "", value: draft, maxLength: ASSISTANT_MESSAGE_MAX_CHARS, placeholder: "Ask anything", "aria-label": "Message", onChange: (event) => {
                             setDraft(event.target.value);
                         }, onKeyDown: composerKeys, onFocus: onTextareaFocus, onBlur: onTextareaBlur }), _jsx(ComposerControlsRow, { draft: draft, attachments: attachments, policy: policy, busy: busy, pendingSend: pendingSend, stopping: stopping, stopTurn: stopTurn, stopOnEscape: stopOnEscape, send: send, attach: attach, textareaRef: textareaRef })] }), gate.kind === "none" ? _jsx(ModelPickerShelf, {}) : null] }));
 }
-// The controls row beneath the draft: attach at the left, the counters
-// and the send slot (arrow or stop square) at the right.
 function ComposerControlsRow({ draft, attachments, policy, busy, pendingSend, stopping, stopTurn, stopOnEscape, send, attach, textareaRef, }) {
     const fileInputRef = useRef(null);
     return (_jsxs("div", { className: "tf:flex tf:items-center tf:gap-2 tf:pt-1", children: [policy !== null ? (_jsxs(_Fragment, { children: [_jsx(TfFileInput, { ref: fileInputRef, multiple: true, accept: attachmentAcceptOf(policy), onPickFiles: attach.addFiles }), _jsx(TfButton, { variant: "icon", onClick: () => {
                             fileInputRef.current?.click();
-                        }, 
-                        // Sending blocks the picker too. The original hazard
-                        // (the landed send's remount vanishing a mid-flight
-                        // pick) is gone — the list lives in the store now —
-                        // but the guard stays: a pick landing between the
-                        // optimistic clear and the refusal restore would
-                        // interleave with that bookkeeping, and holding the
-                        // door for the send beat keeps it unambiguous.
-                        disabled: capSlotsSpentBy(attachments) >= attach.attachmentRoom ||
+                        }, disabled: capSlotsSpentBy(attachments) >= attach.attachmentRoom ||
                             send.sending, "aria-label": "Attach a file", children: _jsx(PlusIcon, {}) })] })) : null, _jsxs("div", { className: "tf:ml-auto tf:flex tf:shrink-0 tf:items-center tf:gap-2", children: [stopping ? (_jsx("span", { role: "status", className: "tf:text-xs tf:text-tf-muted-foreground", children: "Stopping\u2026" })) : null, draft.length >= CHARACTER_COUNT_VISIBLE_FROM ? (_jsxs("span", { className: "tf:text-xs tf:text-tf-muted-foreground", children: [draft.length, "/", ASSISTANT_MESSAGE_MAX_CHARS] })) : null, busy && !pendingSend ? (_jsx(TfButton, { variant: "stop", onClick: () => {
                             void stopTurn();
-                            // The caret goes home immediately: the draft is
-                            // where a member who just stopped an answer types
-                            // next, and Escape (bound on the textarea) stays
-                            // live through the Stopping… beat.
                             textareaRef.current?.focus();
                         }, onKeyDown: stopOnEscape, "aria-disabled": stopping, "aria-label": "Stop generating", children: _jsx(StopIcon, {}) })) : (_jsx(TfButton, { variant: "send", onClick: () => {
                             void send.submitDraft();
                         }, disabled: send.sendDisabled, "aria-label": send.sending ? "Sending message" : "Send message", children: _jsx(ArrowUpIcon, {}) }))] })] }));
 }
-// Where focus lands when the focused element unmounts: the body on a
-// plain page, but inside a modal <dialog> the focus-fixup rule parks it
-// on the dialog element itself. Anything else means the visitor moved
-// focus deliberately and it must not be stolen back.
 function _focusWasDroppedByTheRemount(textarea) {
     const active = document.activeElement;
     return (active === null ||
         active === document.body ||
         (textarea !== null && active === textarea.closest("dialog")));
 }
-//# sourceMappingURL=composer.js.map

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

@@ -1,5 +1,10 @@
 import type { ComposerContract } from "../core/conversation-store.js";
 export type { ComposerContract };
 export declare const ConversationContext: import("react").Context<ComposerContract | null>;
+/**
+ * Returns the live message-box state and controls for the open conversation
+ * (busy and stopping flags, the draft, `sendMessage`, `stopTurn`), for building
+ * your own composer or send buttons. It must be called inside the provider
+ * (from either entry point) and throws otherwise.
+ */
 export declare function useConversation(): ComposerContract;
-//# sourceMappingURL=conversation-context.d.ts.map

package/dist/components/conversation-context.js

@@ -8,4 +8,3 @@ export function useConversation() {
     }
     return value;
 }
-//# sourceMappingURL=conversation-context.js.map

package/dist/components/conversation-gate-card.js

@@ -1,144 +1,80 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useCallback, useEffect } from "react";
-import { humanizedWait } from "../core/error-copy.js";
+import { useEffect } from "react";
 import { OpenAiMarkIcon } from "./icons.js";
 import { TfButton } from "./primitives/button.js";
+import { pollStanding } from "./standing-poll.js";
+import { checkingPlanSentenceOf, HeartbeatLine, ManageUsageLink, notEligibleSentenceOf, planLimitSentenceOf, } from "./subscription-connect-arms.js";
 import { ConnectFlow, DISCLOSURE_LINE, providerNameOf, useSubscriptionConnectFlow, } from "./subscription-connect-flow.js";
+import { useRefreshStandingAndGate, useSubscriptionRecheck, } from "./subscription-recheck.js";
 import { useAssistantSession } from "./teaflask-assistant-provider.js";
 import { useCell } from "./use-store-cell.js";
-// The conversation gate banner: when the next send cannot serve without
-// the visitor acting, the moment renders as an INLINE banner above the
-// composer — the chat-product grammar (owner reference: ChatGPT's limit
-// banner, 2026-08-20) — never a takeover of the input. One tinted strip:
-// the state as a sentence on the left, one intrinsic-width action on the
-// right, and the composer stays where it always is. Starting the connect
-// expands the device-code flow inside the same strip; a landed
-// credential clears the gate on the next projection read and the banner
-// simply leaves.
-// While the gate reports verifying (a fresh credential's probe, or the
-// server re-checking a stale quota), re-read at the flow's own gentle
-// pace, bounded the same way.
-const _VERIFYING_REFRESH_MS = 4000;
-const _MAX_VERIFYING_REFRESH_ATTEMPTS = 5;
-// setTimeout's delay is a 32-bit signed int: past ~24.8 days it
-// overflows and fires IMMEDIATELY — and a monthly plan window's reset
-// horizon is exactly that far away. An immediate fire re-reads the
-// projection, whose recomputed horizon drifts by the round trip, which
-// defeats the gate dedupe and re-arms into a continuous GET storm. The
-// ceiling guard, like the floor's: a clamped timer just re-checks
-// early and re-arms with the remaining wait.
 const _MAX_TIMEOUT_MS = 2 ** 31 - 1;
 export function ConversationGateCard({ gate, }) {
     const session = useAssistantSession();
-    // The gate implies an identified visitor (anonymous visitors gate on
-    // sign-in, which never reaches this banner) — the standing read serves.
     useEffect(() => {
-        session.ensureSubscriptions();
-    }, [session]);
-    // Every refresh the flow performs also re-reads the projection: the
-    // probe settling active is what clears this banner. Memoized on the
-    // stable session: the flow's poll effect and the verifying chain key
-    // their dependency arrays on this callback, and a fresh identity per
-    // render would tear them down mid-flight — the poll re-arming from
-    // scratch on every re-render, the chain's attempts counter resetting
-    // and defeating its own bound.
-    const refreshStandingAndGate = useCallback(() => {
         session.refreshSubscriptions();
-        session.refreshAssistantConfig();
     }, [session]);
-    return (
-    // The tinted strip: the hover-wash ground carries it (a policy
-    // moment, never the destructive register), rounded to the card step,
-    // flat — it sits in the flow (The Portal Lift Rule).
-    _jsx("div", { className: "tf:mb-3 tf:flex tf:flex-col tf:gap-2 tf:rounded-xl tf:bg-tf-accent tf:p-3", children: gate.kind === "connect" ? (_jsx(ConnectGateBody, { gate: gate, refresh: refreshStandingAndGate })) : gate.kind === "wait" ? (_jsx(WaitGateBody, { retryAtMs: gate.retryAtMs })) : (_jsx(VerifyingGateBody, { refresh: refreshStandingAndGate })) }));
+    const refreshStandingAndGate = useRefreshStandingAndGate();
+    return (_jsx("div", { className: "tf:mb-3 tf:flex tf:flex-col tf:gap-2 tf:rounded-xl tf:bg-tf-accent tf:p-3", children: gate.kind === "connect" ? (_jsx(ConnectGateBody, { gate: gate, refresh: refreshStandingAndGate })) : gate.kind === "wait" ? (_jsx(WaitGateBody, { retryAtMs: gate.retryAtMs, refresh: refreshStandingAndGate })) : (_jsx(VerifyingGateBody, { refresh: refreshStandingAndGate })) }));
 }
 function ConnectGateBody({ gate, refresh, }) {
     const session = useAssistantSession();
     const statuses = useCell(session.subscriptions);
     const status = _theGatesStanding(gate, statuses);
     if (status === null) {
-        // The standing read is still in flight (the banner can beat it by a
-        // breath); the row renders the affordance the moment it lands.
-        return _jsx(_StatusLine, { sentence: "One moment\u2026" });
+        return _jsx(HeartbeatLine, { sentence: "One moment\u2026", tone: "foreground" });
     }
     return _jsx(ConnectBannerRow, { status: status, gate: gate, refresh: refresh });
 }
 function ConnectBannerRow({ status, gate, refresh, }) {
     const session = useAssistantSession();
     const name = providerNameOf(status.provider);
-    const connect = useSubscriptionConnectFlow(status, session.session, refresh);
-    // A running (or failed) flow expands inside the strip — the code, the
-    // approve link, and the waiting line replace the one-row ask.
+    const connect = useSubscriptionConnectFlow(status, session.session, refresh, () => {
+        session.notePlanSignedIn(status.provider);
+    });
     if (connect.flow.kind !== "idle") {
-        return (_jsx(ConnectFlow, { name: name, flow: connect.flow, errorSentence: connect.errorSentence, onBegin: connect.begin, onCancel: connect.cancel, beginLabel: `Sign in with ${name}` }));
+        return (_jsx(ConnectFlow, { name: name, flow: connect.flow, errorSentence: connect.errorSentence, onBegin: connect.begin, onCancel: connect.cancel }));
     }
     const taster = gate.reason === "taster_exhausted";
-    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:flex-wrap tf:items-center tf:gap-x-3 tf:gap-y-2", children: [_jsxs("p", { className: "tf:m-0 tf:flex tf:min-w-0 tf:flex-1 tf:items-center tf:gap-2 tf:text-tf-label tf:text-tf-foreground", children: [_jsx(OpenAiMarkIcon, {}), taster
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:flex-wrap tf:items-center tf:gap-x-3 tf:gap-y-2", children: [_jsxs("p", { className: "tf:m-0 tf:flex tf:min-w-56 tf:flex-1 tf:items-center tf:gap-2 tf:text-tf-label tf:text-tf-foreground", children: [_jsx(OpenAiMarkIcon, {}), taster
                                 ? "You've used the free preview on this assistant."
-                                : `Your ${name} connection stopped working.`] }), _jsx(TfButton, { variant: "primary", className: "tf:shrink-0", onClick: connect.begin, children: taster ? `Sign in with ${name}` : `Reconnect ${name}` })] }), taster ? (_jsx("p", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: DISCLOSURE_LINE })) : null] }));
+                                : status.bounce_cause === "not_eligible"
+                                    ? notEligibleSentenceOf(name)
+                                    : `Your ${name} connection stopped working.`] }), _jsx(TfButton, { variant: "primary", className: "tf:shrink-0", onClick: connect.begin, children: taster ? `Sign in with ${name}` : `Reconnect ${name}` })] }), taster ? (_jsx("p", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: DISCLOSURE_LINE })) : null] }));
 }
-function WaitGateBody({ retryAtMs }) {
+function WaitGateBody({ retryAtMs, refresh, }) {
     const session = useAssistantSession();
-    // When the recorded reset passes, re-read the projection: the send
-    // door will have flipped to the re-checking arm (or cleared entirely),
-    // and the banner must not keep promising a wait that is over.
+    const statuses = useCell(session.subscriptions);
+    const status = _thePlanLimitedStanding(statuses);
+    const name = providerNameOf(status?.provider ?? "openai_chatgpt");
+    const recheck = useSubscriptionRecheck(status, session.session, refresh);
     useEffect(() => {
         if (retryAtMs === null) {
             return;
         }
-        const timer = window.setTimeout(() => {
-            session.refreshAssistantConfig();
-        }, Math.min(Math.max(1000, retryAtMs - Date.now()), _MAX_TIMEOUT_MS));
+        const timer = window.setTimeout(refresh, Math.min(Math.max(1000, retryAtMs - Date.now()), _MAX_TIMEOUT_MS));
         return () => {
             window.clearTimeout(timer);
         };
-    }, [retryAtMs, session]);
-    return (_jsxs("p", { className: "tf:m-0 tf:flex tf:items-center tf:gap-2 tf:text-tf-label tf:text-tf-foreground", children: [_jsx(OpenAiMarkIcon, {}), "Your ChatGPT plan's included usage is used up for this period.", " ", _theContinuePromiseOf(retryAtMs)] }));
+    }, [retryAtMs, refresh]);
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "tf:flex tf:flex-wrap tf:items-center tf:gap-x-3 tf:gap-y-2", children: [_jsxs("p", { className: "tf:m-0 tf:flex tf:min-w-56 tf:flex-1 tf:items-center tf:gap-2 tf:text-tf-label tf:text-tf-foreground", children: [_jsx(OpenAiMarkIcon, {}), planLimitSentenceOf(name)] }), recheck.rechecking ? (_jsx(HeartbeatLine, { sentence: checkingPlanSentenceOf(name) })) : (_jsxs("div", { className: "tf:flex tf:shrink-0 tf:flex-wrap tf:items-center tf:gap-2", children: [_jsx(ManageUsageLink, { provider: status?.provider ?? "openai_chatgpt" }), _jsx(TfButton, { variant: "outline", disabled: status === null, onClick: recheck.recheck, children: "Check again" })] }))] }), recheck.errorSentence === null ? null : (_jsx("p", { className: "tf:m-0 tf:text-tf-label tf:text-tf-destructive", role: "alert", children: recheck.errorSentence }))] }));
 }
-function _theContinuePromiseOf(retryAtMs) {
-    const secondsLeft = retryAtMs === null ? null : Math.ceil((retryAtMs - Date.now()) / 1000);
-    if (secondsLeft !== null && secondsLeft > 0) {
-        return `The conversation can continue in about ${humanizedWait(secondsLeft)}.`;
-    }
-    return "The conversation can continue when it resets.";
+function _thePlanLimitedStanding(statuses) {
+    return (statuses?.find((status) => status.connected &&
+        status.offered &&
+        status.state === "bounced" &&
+        status.bounce_cause === "quota") ?? null);
 }
 function VerifyingGateBody({ refresh }) {
     const session = useAssistantSession();
     const statuses = useCell(session.subscriptions);
     const aCredentialIsVerifying = statuses?.some((status) => status.state === "verifying") ?? false;
-    // The bounded re-read chain (the flow's discipline): the probe settles
-    // in moments, and each landed read restarts the chain via the fresh
-    // render — a failed read re-arms itself up to the bound.
-    useEffect(() => {
-        let attempts = 0;
-        let timer;
-        const arm = () => {
-            timer = window.setTimeout(() => {
-                attempts += 1;
-                refresh();
-                if (attempts < _MAX_VERIFYING_REFRESH_ATTEMPTS) {
-                    arm();
-                }
-            }, _VERIFYING_REFRESH_MS);
-        };
-        arm();
-        return () => {
-            if (timer !== undefined) {
-                window.clearTimeout(timer);
-            }
-        };
-    }, [statuses, refresh]);
-    return (_jsx(_StatusLine, { sentence: aCredentialIsVerifying
+    useEffect(() => pollStanding(refresh), [statuses, refresh]);
+    return (_jsx(HeartbeatLine, { sentence: aCredentialIsVerifying
             ? "Verifying your ChatGPT connection…"
-            : "Re-checking your plan — one moment…" }));
-}
-function _StatusLine({ sentence }) {
-    return (_jsxs("p", { className: "tf:m-0 tf:flex tf:items-center tf:gap-1.5 tf:text-tf-label tf:text-tf-foreground", role: "status", children: [_jsx("span", { "aria-hidden": true, className: "tf:size-1.5 tf:shrink-0 tf:animate-tf-pulse tf:rounded-full tf:bg-tf-foreground tf:motion-reduce:animate-none" }), sentence] }));
+            : "Re-checking your plan — one moment…", tone: "foreground" }));
 }
-// The standing the gate spoke about: the named provider's row first,
-// else the first row a flow could act on. Null while the read is in
-// flight — never a fabricated status.
 function _theGatesStanding(gate, statuses) {
     if (statuses === null) {
         return null;
@@ -149,4 +85,3 @@ function _theGatesStanding(gate, statuses) {
     }
     return statuses.find((status) => status.offered || status.connected) ?? null;
 }
-//# sourceMappingURL=conversation-gate-card.js.map