@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/teaflask-assistant-provider.d.ts

@@ -3,7 +3,7 @@ import { type AssistantTheme, type AssistantThemeMode } from "../appearance/them
 import type { ActionsAdapter } from "../contract/actions-adapter.js";
 import type { ServedAttachmentPolicy, ServedModelChoice, ServedSuggestionsConfig } from "../contract/assistant-config.js";
 import type { VisitorTier } from "../contract/identity.js";
-import type { SubscriptionStatus } from "../contract/subscriptions.js";
+import type { SubscriptionProvider, SubscriptionStatus } from "../contract/subscriptions.js";
 import type { AssistantTelemetryEvent } from "../contract/telemetry.js";
 import type { ConversationGate } from "../core/connect-gate.js";
 import type { ReadonlyCell } from "../core/observable-cell.js";
@@ -13,86 +13,120 @@ import type { ServingApiError } from "../transport/serving-error.js";
 import type { TokenSession } from "../transport/token-session.js";
 import type { ToolViewRegistry } from "../core/tool-view.js";
 import type { AssistantSuggestionInput } from "./conversation-view.js";
-export interface TeaflaskAssistantProviderProps {
+/**
+ * The identity props for a signed-in user, always passed together. When
+ * `userId` changes, including to undefined on sign-out, everything from the
+ * previous user is dropped and a fresh session starts.
+ */
+export interface TeaflaskAssistantIdentityProps {
+    /**
+     * Your stable id for the signed-in user. It must equal the `user_id` claim
+     * in the token that `getEndUserToken` returns, or the assistant shows a
+     * setup error instead of a conversation.
+     */
+    userId: string;
+    /**
+     * Returns a short-lived token from your backend that proves who the user
+     * is: an HS256 JWT with `user_id` and `exp` (and optionally `email`),
+     * signed with the JWT secret from Settings → Keys in Teaflask. It is called
+     * whenever the assistant needs a new session token, and returning null
+     * continues anonymously.
+     */
+    getEndUserToken: () => string | null | Promise<string | null>;
+}
+/**
+ * The identity props for a page with no signed-in user. Leave both `userId` and
+ * `getEndUserToken` unset, and the visitor chats anonymously.
+ */
+export interface TeaflaskAssistantAnonymousProps {
+    /** Leave unset for anonymous visitors. */
+    userId?: undefined;
+    /** Leave unset for anonymous visitors. */
+    getEndUserToken?: undefined;
+}
+/**
+ * Props for `TeaflaskAssistantProvider`. Pass the shared props, plus either
+ * both `userId` and `getEndUserToken` for a signed-in user or neither for an
+ * anonymous visitor.
+ */
+export type TeaflaskAssistantProviderProps = TeaflaskAssistantProviderBaseProps & (TeaflaskAssistantIdentityProps | TeaflaskAssistantAnonymousProps);
+/**
+ * The props shared by `TeaflaskAssistantProvider` and `TeaflaskAssistant`,
+ * except the identity pair. Changing `publishableKey`, `baseUrl` or `userId`
+ * starts a separate session.
+ */
+export interface TeaflaskAssistantProviderBaseProps {
+    /**
+     * Your agent's publishable key from Teaflask. It is meant for browser code,
+     * and requests are accepted only from your allowed origins.
+     */
     publishableKey: string;
+    /**
+     * The Teaflask API origin, which defaults to `https://api.teaflask.com`. A
+     * trailing slash is ignored.
+     */
     baseUrl?: string;
-    getEndUserToken?: () => string | null | Promise<string | null>;
     /**
-     * How this page performs the actions the org's catalog grants (the
-     * http_intent execution request) — see the ActionsAdapter contract.
-     * Absent means this surface cannot perform actions: the assistant is
-     * told so in-band and tells the user what to do themselves.
+     * How this page calls your API when the agent runs an action, with the
+     * user's own cookies, headers or a request you build. Without it, the agent
+     * cannot run actions here and tells the user to do the step themselves.
      */
     actionsAdapter?: ActionsAdapter;
     /**
-     * How this page takes the visitor to an app-relative path when the
-     * assistant asks (the builtin.navigate execution request). Absent means
-     * this surface cannot navigate: the assistant is told so in-band. May be
-     * async; resolve once the navigation has been handed to the host's router.
+     * Called with an app-relative path when the agent takes the user to a page,
+     * so wire it to your router. It may return a promise that resolves once
+     * your router has the navigation. Without it, the agent cannot navigate on
+     * this page.
      */
     onNavigate?: (path: string) => void | Promise<void>;
+    /**
+     * Called with errors for your error reporting: a failed send or stop, a
+     * dropped stream, a conversation that fails to open, a failed session-token
+     * request, or a crash inside an assistant surface.
+     */
     onError?: (error: Error) => void;
     /**
-     * Observer for the package's product-telemetry events — the approval
-     * submit path's attempted/sent/dropped narration, for hosts that
-     * forward product analytics (the dashboard sends these to PostHog).
-     * Distinct from onError on purpose: these are events, not failures,
-     * and most carry no exception.
+     * Called with product analytics events (approval submits and stream
+     * failures) that you can forward to your own analytics. If it throws, the
+     * error goes to `onError`.
      */
     onTelemetry?: (event: AssistantTelemetryEvent) => void;
     /**
-     * JS theming over the same 21 public tokens as the CSS route, in
-     * camelCase (`primaryForeground` sets `--tf-primary-foreground`), plus a
-     * nested `dark` variant. Values land as inline style variables on the
-     * widget roots, so an explicit prop beats ambient host CSS. Read by value
-     * — a fresh literal every render never resets conversation state. Inline
-     * styles need `style-src 'unsafe-inline'` (or `style-src-attr`) under a strict CSP; theme
-     * through the CSS route instead if that is not allowed.
+     * Theme tokens and dark-mode overrides, compared by value, so passing a new
+     * object literal on every render is fine. Under a strict Content Security
+     * Policy this needs inline styles allowed (`style-src-attr`). Otherwise set
+     * the `--tf-` variables in your CSS instead.
      */
     theme?: AssistantTheme;
     /**
-     * Writes `data-tf-theme` on the widget roots: `"dark"` pins the dark
-     * palette, `"light"` pins light even under an ancestor's dark
-     * attribute, `"auto"` follows the visitor's OS preference (a CSS media
-     * query — no script runs). Omit it and the attribute stays the host's
-     * to manage on any ancestor.
+     * Forces light, dark or OS-following (`"auto"`) colors on every assistant
+     * surface. Omit it to stay light unless an ancestor element carries
+     * `data-tf-theme="dark"`.
      */
     mode?: AssistantThemeMode;
     /**
-     * Your own companion mark, rendered on the corner perch and the
-     * drawer's welcome inside one box the package sizes (4rem on both).
-     * The package sets your node to 100% width and height of that box, so
-     * a bare `<svg viewBox>` or `<img>` fills it without sizing itself;
-     * keep the artwork's aspect inside the viewBox. A
-     * sibling of `theme` on purpose — the mark is identity, not a theme
-     * token. Read by identity like `toolViews`. Omit it for the TeaFlask
-     * flask in the foreground color — `flag && <Mark />` on its false arm
-     * counts as omitted, like every host fill in the package.
+     * Your own logo or mascot, shown on the corner widget and on the drawer's
+     * welcome screen. It fills a 4rem square, so a bare `<svg viewBox>` or
+     * `<img>` works without sizing. Omit it, or pass a falsy value, to show the
+     * Teaflask flask.
      */
     companionMark?: ReactNode;
     /**
-     * Opening prompts for the companion drawer's first-run welcome. A bare
-     * string renders as an `ask`; `{ prompt, kind }` picks the glyph. Read by
-     * value like `theme`. Omit it and the drawer serves the prompts authored
-     * on the organization's assistant, matched to the page's path. Passing
-     * any value — even `[]` — overrides the served sets wholesale, never
-     * merges: explicit JS intent beats remote config.
+     * Opening prompts for the drawer's welcome screen, compared by value. Omit
+     * it to use the prompts configured for your agent in Teaflask for the
+     * current page. Any value, even `[]`, replaces those entirely.
      */
     suggestions?: readonly AssistantSuggestionInput[];
     /**
-     * The trusted-host tool-view registry (tool-views.md): adapters this
-     * host compiled and deployed, keyed by the opaque namespaced key a
-     * backend display annotation may name (rung 1: exact key AND version)
-     * or by the host's own exact tool name (rung 2). A registration carries
-     * a view, an icon, or both; absence, mismatch, or a throw falls to the
-     * rung below, terminally the package default view. Adapters receive
-     * exactly `ToolViewProps` — never stores, tokens, or transport, and never
-     * approve/deny. `teaflask.*` keys are reserved for package built-ins.
-     * Read by identity but never memo-keyed: a fresh literal every render
-     * never resets conversation state (registries should still live at
-     * module scope — the mount slot keys the adapter lifecycle on identity).
+     * Your own components for displaying specific tools and actions in the
+     * conversation, keyed by tool name (`action__<slug>` for an action). Define
+     * the registry once at module scope rather than inside a component.
      */
     toolViews?: ToolViewRegistry;
+    /**
+     * Your app content. Components inside it can use the assistant hooks, such
+     * as `useAssistantActivity` and `useConversation`.
+     */
     children?: ReactNode;
 }
 interface AssistantSessionValue {
@@ -117,19 +151,18 @@ interface AssistantSessionValue {
     connectOpenRequested: ReadonlyCell<boolean>;
     requestSubscriptionConnect: () => void;
     acknowledgeSubscriptionConnect: () => void;
+    planNoticeDue: ReadonlyCell<SubscriptionProvider | null>;
+    notePlanSignedIn: (provider: SubscriptionProvider) => void;
+    acknowledgePlanNotice: () => void;
     reportError: (error: Error) => void;
 }
 export declare function useAssistantSession(): AssistantSessionValue;
-/** The tolerant read for components with a degraded no-session rendering
- *  (the composer's paperclip, an attachment's inline image) — outside the
- *  provider they hide the affordance instead of throwing, which is also
- *  what lets welcome-branch tests render the view bare. */
 export declare function useOptionalAssistantSession(): AssistantSessionValue | null;
 /**
- * Owns the visitor-token session and the identity handshake. Deliberately
- * no visitorToken, data, or agent props — the package speaks only the
- * public contract (each of those would be a dogfood escape hatch).
+ * Connects to Teaflask and shares one live conversation with every assistant
+ * component and hook inside it, without rendering any UI of its own. Use it in
+ * place of `TeaflaskAssistant` when you place the surfaces yourself or build
+ * your own UI.
  */
-export declare function TeaflaskAssistantProvider({ publishableKey, baseUrl, getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, theme, mode, companionMark, suggestions, toolViews, children, }: TeaflaskAssistantProviderProps): import("react").JSX.Element;
+export declare function TeaflaskAssistantProvider({ publishableKey, baseUrl, userId, getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, theme, mode, companionMark, suggestions, toolViews, children, }: TeaflaskAssistantProviderProps): import("react").JSX.Element;
 export {};
-//# sourceMappingURL=teaflask-assistant-provider.d.ts.map

package/dist/components/teaflask-assistant-provider.js

@@ -4,6 +4,7 @@ import { createContext, useCallback, useContext, useEffect, useMemo, useRef, } f
 import { themeToStyleVars, } from "../appearance/theme.js";
 import { assistantSessionRegistry, } from "../core/assistant-session-registry.js";
 import { hostFillDeclines } from "../core/host-fill.js";
+import { IDENTITY_PAIR_WARNING, identityPairIsHalfSet, namedIdentityOf, } from "../core/identity-pair.js";
 import { performActionIntent } from "../transport/actions-adapter.js";
 import { AssistantAppearanceContext, } from "./appearance-context.js";
 import { ToolViewRegistryContext } from "./tool-view-registry-context.js";
@@ -17,27 +18,24 @@ export function useAssistantSession() {
     }
     return value;
 }
-/** The tolerant read for components with a degraded no-session rendering
- *  (the composer's paperclip, an attachment's inline image) — outside the
- *  provider they hide the affordance instead of throwing, which is also
- *  what lets welcome-branch tests render the view bare. */
 export function useOptionalAssistantSession() {
     return useContext(AssistantSessionContext);
 }
-/**
- * Owns the visitor-token session and the identity handshake. Deliberately
- * no visitorToken, data, or agent props — the package speaks only the
- * public contract (each of those would be a dogfood escape hatch).
- */
-export function TeaflaskAssistantProvider({ publishableKey, baseUrl, getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, theme, mode, companionMark, suggestions, toolViews, children, }) {
+export function TeaflaskAssistantProvider({ publishableKey, baseUrl, userId, getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, theme, mode, companionMark, suggestions, toolViews, children, }) {
+    const identity = useNamedIdentity({ userId, getEndUserToken });
     const host = useHostCallbackRefs({
-        getEndUserToken,
+        getEndUserToken: identity?.getEndUserToken,
         actionsAdapter,
         onNavigate,
         onError,
         onTelemetry,
     });
-    const value = useSessionRegistration({ publishableKey, baseUrl, host });
+    const value = useSessionRegistration({
+        publishableKey,
+        baseUrl,
+        userId: identity?.userId,
+        host,
+    });
     const appearance = useAppearanceValue({
         theme,
         mode,
@@ -46,12 +44,18 @@ export function TeaflaskAssistantProvider({ publishableKey, baseUrl, getEndUserT
     });
     return (_jsx(AssistantSessionContext.Provider, { value: value, children: _jsx(AssistantAppearanceContext.Provider, { value: appearance, children: _jsx(ToolViewRegistryContext.Provider, { value: toolViews ?? null, children: _jsx(ConversationSurfacesProvider, { store: value.store, children: children }) }) }) }));
 }
-/** The host's callbacks behind identity-stable wrappers, so hosts that
- *  pass inline arrows never disturb the session or the store. */
+let warnedHalfSetPair = false;
+function useNamedIdentity(input) {
+    const halfSet = identityPairIsHalfSet(input);
+    useEffect(() => {
+        if (halfSet && !warnedHalfSetPair) {
+            warnedHalfSetPair = true;
+            console.warn(`[teaflask-assistant] ${IDENTITY_PAIR_WARNING}`);
+        }
+    }, [halfSet]);
+    return namedIdentityOf(input);
+}
 function useHostCallbackRefs({ getEndUserToken, actionsAdapter, onNavigate, onError, onTelemetry, }) {
-    // Latest-callback refs keep the TokenSession identity stable across
-    // re-renders that only changed the closures (hosts often pass inline
-    // arrows). Updated in an effect per the hooks lint law.
     const getEndUserTokenRef = useRef(getEndUserToken);
     const actionsAdapterRef = useRef(actionsAdapter);
     const onNavigateRef = useRef(onNavigate);
@@ -79,9 +83,6 @@ function useHostCallbackRefs({ getEndUserToken, actionsAdapter, onNavigate, onEr
         onTelemetryRef.current?.(event);
     }, []);
     const telemetryProvided = onTelemetry !== undefined;
-    // What this page can execute, read fresh by the store at each execution
-    // pass — hosts re-wire navigation/actions across renders and the store's
-    // identity must not depend on theirs.
     const hostCapabilitiesRef = useRef({
         navigate: null,
         executeActionIntent: null,
@@ -106,25 +107,11 @@ function useHostCallbackRefs({ getEndUserToken, actionsAdapter, onNavigate, onEr
         hostCapabilitiesOf,
     };
 }
-/** Resolves the shared session entry, holds it retained for the mounted
- *  lifetime, and shapes the context value every surface reads. */
-function useSessionRegistration({ publishableKey, baseUrl, host, }) {
+function useSessionRegistration({ publishableKey, baseUrl, userId, host, }) {
     const { identityProvided, actionsProvided, navigationProvided, telemetryProvided, resolveEndUserToken, hostNavigate, executeActionIntent, reportError, recordTelemetry, hostCapabilitiesOf, } = host;
-    // The registry resolves the session's identity inputs to ONE shared
-    // TokenSession + store pair — same-identity providers, even in other
-    // React roots (two custom elements on one host page), converse through
-    // the same store. Render-safe: entryFor only constructs, never boots.
-    const entry = useMemo(() => assistantSessionRegistry.entryFor({
-        publishableKey,
-        baseUrl,
-        identityProvided,
-    }), [publishableKey, baseUrl, identityProvided]);
+    const entry = useMemo(() => assistantSessionRegistry.entryFor({ publishableKey, baseUrl, userId }), [publishableKey, baseUrl, userId]);
     const session = entry.session;
     const store = entry.store;
-    // This provider's wiring rides the entry for exactly the mounted
-    // lifetime: the first retain boots the store, the last release
-    // disposes store and session (the registry's ref-count replaces the
-    // per-provider dispose that lived here).
     useEffect(() => {
         const registrant = {
             resolveEndUserToken: identityProvided ? resolveEndUserToken : null,
@@ -142,9 +129,6 @@ function useSessionRegistration({ publishableKey, baseUrl, host, }) {
         telemetryProvided,
         recordTelemetry,
     ]);
-    // The mint's verdict lives on the entry, not in provider state: a
-    // provider mounting after the mint answered reads the cached verdict
-    // instead of waiting for a mint that already happened.
     const tier = useCell(entry.tier);
     const setupError = useCell(entry.setupError);
     return useMemo(() => ({
@@ -169,6 +153,9 @@ function useSessionRegistration({ publishableKey, baseUrl, host, }) {
         connectOpenRequested: entry.connectOpenRequested,
         requestSubscriptionConnect: entry.requestSubscriptionConnect,
         acknowledgeSubscriptionConnect: entry.acknowledgeSubscriptionConnect,
+        planNoticeDue: entry.planNoticeDue,
+        notePlanSignedIn: entry.notePlanSignedIn,
+        acknowledgePlanNotice: entry.acknowledgePlanNotice,
         reportError,
     }), [
         session,
@@ -185,19 +172,9 @@ function useSessionRegistration({ publishableKey, baseUrl, host, }) {
         reportError,
     ]);
 }
-/** A host's mark, or null for the package flask — the fall-through rule
- *  (core/host-fill.ts): the idiomatic `companionMark={flag && <Mark />}`
- *  gets the flask on its false arm; renderable emptiness is the host's
- *  deliberate content. Folded once, here, because CompanionMark branches
- *  on null. */
 function _companionMarkOf(companionMark) {
     return hostFillDeclines(companionMark) ? null : companionMark;
 }
-/** The theme and suggestions props travel by value, not identity: hosts
- *  write both as inline literals. Serializing once and keying the memo on
- *  the strings keeps those identities out of every dependency array here.
- *  The companion mark is the exception — a ReactNode has no value form,
- *  so it rides by identity, like toolViews. */
 function useAppearanceValue({ theme, mode, companionMark, suggestions, }) {
     const themeJson = theme === undefined ? null : JSON.stringify(theme);
     const suggestionsJson = suggestions === undefined ? null : JSON.stringify(suggestions);
@@ -218,13 +195,9 @@ function useAppearanceValue({ theme, mode, companionMark, suggestions, }) {
         };
     }, [themeJson, mode, companionMark, suggestionsJson]);
 }
-// The context value only exposes the executor when the adapter prop is
-// present, so an empty ref here is a package bug, not a host mistake —
-// but the narrowing must still be explicit for the lint laws.
 function _wiredAdapterOf(adapter) {
     if (adapter === undefined) {
         throw new Error("The actions adapter was removed while an action was executing.");
     }
     return adapter;
 }
-//# sourceMappingURL=teaflask-assistant-provider.js.map

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

@@ -1,29 +1,44 @@
 import { type AssistantCompanionProps } from "./assistant-companion.js";
 import { type TeaflaskAssistantProviderProps } from "./teaflask-assistant-provider.js";
+/**
+ * The imperative handle you get through a ref on `TeaflaskAssistant`. It exists
+ * only while the component is mounted.
+ */
 export interface TeaflaskAssistantHandle {
     /**
-     * Opens the palette regardless of the hotkey setting — the imperative
-     * escape hatch for a host that disabled or rebound the chord. Call it
-     * through the ref's optional chain (`ref.current?.openPalette()`): the
-     * handle exists only while the root is mounted, so an early or late
-     * call no-ops instead of throwing. Opening the palette makes the
-     * companion yield (hide) until it closes — by design: the palette
-     * counts as an open assistant surface.
+     * Opens the ⌘K palette even when the hotkey is disabled or rebound. The
+     * corner widget hides while the palette is open. Call it as
+     * `ref.current?.openPalette()`.
      */
     openPalette: () => void;
 }
-export interface TeaflaskAssistantProps extends TeaflaskAssistantProviderProps {
+/**
+ * The props `TeaflaskAssistant` adds on top of the provider's, for the palette
+ * hotkey and the widget's corner.
+ */
+export interface TeaflaskAssistantRootProps {
     /**
-     * The palette chord, "mod+k" by default (mod = ⌘ or Ctrl). Rebind with
-     * the same grammar ("mod+j", "ctrl+shift+p") when your app already
-     * spends ⌘K, or pass false to disable — the ref handle still opens the
-     * palette. An unrecognized spec disables the hotkey with a console
-     * warning rather than falling back: a host rebinding away from a
-     * conflict must never be silently rebound into it.
+     * The keyboard shortcut that toggles the palette. It defaults to `"mod+k"`,
+     * where mod is ⌘ on macOS and Ctrl elsewhere, and takes the same syntax for
+     * other keys (`"mod+j"`, `"ctrl+shift+p"`). Pass `false` to disable it. An
+     * unrecognized value also disables it, with a console warning, and a key
+     * press your own handler calls `preventDefault()` on is ignored.
      */
     hotkey?: string | false;
-    /** The viewport corner the companion (and its drawer) anchor to. */
+    /**
+     * The screen corner where the widget and its drawer sit. The default is
+     * `"bottom-right"`.
+     */
     corner?: AssistantCompanionProps["corner"];
 }
+/**
+ * Props for `TeaflaskAssistant`, which are all the provider props plus `hotkey`
+ * and `corner`.
+ */
+export type TeaflaskAssistantProps = TeaflaskAssistantProviderProps & TeaflaskAssistantRootProps;
+/**
+ * The all-in-one assistant. It contains the provider plus the corner widget
+ * (which opens the chat drawer) and the ⌘K palette, so mount it once in the
+ * layout that wraps every page. Pass a ref to get a `TeaflaskAssistantHandle`.
+ */
 export declare const TeaflaskAssistant: import("react").ForwardRefExoticComponent<TeaflaskAssistantProps & import("react").RefAttributes<TeaflaskAssistantHandle>>;
-//# sourceMappingURL=teaflask-assistant.d.ts.map

package/dist/components/teaflask-assistant.js

@@ -5,9 +5,6 @@ import { DEFAULT_ASSISTANT_HOTKEY, hotkeyMatches, parseHotkey, } from "../core/h
 import { AssistantCompanion, } from "./assistant-companion.js";
 import { AssistantPalette } from "./assistant-palette.js";
 import { TeaflaskAssistantProvider, } from "./teaflask-assistant-provider.js";
-// forwardRef rather than ref-as-prop: the peer range admits React 18.3,
-// where a function component receives no ref through props. The ref
-// carries TeaflaskAssistantHandle (see its doc above).
 export const TeaflaskAssistant = forwardRef(function TeaflaskAssistant({ hotkey = DEFAULT_ASSISTANT_HOTKEY, corner, children, ...providerProps }, ref) {
     const [paletteOpen, setPaletteOpen] = useState(false);
     const openPalette = useCallback(() => {
@@ -24,18 +21,12 @@ export const TeaflaskAssistant = forwardRef(function TeaflaskAssistant({ hotkey
                 return;
             }
             if (event.repeat) {
-                // OS auto-repeat while the chord is held: one press is one
-                // toggle, not a flicker that lands wherever the key-up falls.
                 return;
             }
             if (event.defaultPrevented) {
-                // A host handler acted on this chord first — cooperate.
                 return;
             }
             event.preventDefault();
-            // A functional toggle: pure under StrictMode, always reads the
-            // committed truth, and keeps the subscription keyed on the binding
-            // alone.
             setPaletteOpen((open) => !open);
         };
         window.addEventListener("keydown", togglePaletteOnHotkey);
@@ -45,13 +36,7 @@ export const TeaflaskAssistant = forwardRef(function TeaflaskAssistant({ hotkey
     }, [binding]);
     return (_jsxs(TeaflaskAssistantProvider, { ...providerProps, children: [children, _jsx(AssistantCompanion, { corner: corner }), _jsx(AssistantPalette, { open: paletteOpen, onOpenChange: setPaletteOpen })] }));
 });
-// Bad specs warn once each, not once per render — a root re-rendering
-// sixty times a second must not flood the console with the same typo.
 const warnedHotkeySpecs = new Set();
-// The active binding, or null when the hotkey is off: disabled by the
-// host, or disabled by an unparseable spec (warn-then-degrade, the
-// companion loader's manner — never a silent fallback to the very chord
-// the host was rebinding away from).
 function _bindingOf(hotkey) {
     if (hotkey === false) {
         return null;
@@ -65,4 +50,3 @@ function _bindingOf(hotkey) {
     }
     return binding;
 }
-//# sourceMappingURL=teaflask-assistant.js.map

package/dist/components/thread-list.js

@@ -4,34 +4,12 @@ import { RECENT_WINDOW_DAYS, startOfLocalDayMs } from "../core/time-labels.js";
 import { ComposeIcon } from "./icons.js";
 import { TfButton } from "./primitives/button.js";
 import { cx } from "./primitives/cx.js";
-/**
- * History bucketed the way people remember it — by calendar day, not by
- * elapsed hours: a conversation from 11pm last night is "Yesterday" at
- * 8am even though it is nine hours old. Grouping is also why the rows
- * carry no timestamp of their own; the heading already said it, and a
- * right-aligned time would eat the title in a 280px rail.
- */
 export function groupThreadsByRecency(threads, now) {
-    // Each boundary is a local midnight of its own, counted back in
-    // CALENDAR days (startOfLocalDayMs — hoisted to core/time-labels so
-    // the user-bubble timestamps read this exact recency rule).
     const startOfDay = (daysBack) => startOfLocalDayMs(now, daysBack);
     const startOfToday = startOfDay(0);
     const startOfYesterday = startOfDay(1);
     const startOfRecentWindow = startOfDay(RECENT_WINDOW_DAYS);
     const buckets = new Map();
-    // Groups come out in the order their first thread arrives, so the sort
-    // decides the headings' order too. An unparseable stamp is therefore ranked
-    // rather than left to arithmetic: it sorts to the very top, which is where
-    // its "Today" bucket belongs.
-    //
-    // Compared, not subtracted, so the comparator is total. Ranking alone did
-    // not achieve that, whatever the older wording here claimed: two
-    // unparseable stamps both rank Infinity, and `Infinity - Infinity` is NaN.
-    // That particular NaN is in fact harmless — SortCompare coerces it to +0,
-    // and "equal" is the honest answer for two threads that are equally
-    // unrankable — but a comparator whose totality rests on a spec footnote is
-    // one refactor away from mattering.
     const ordered = [...threads].sort((a, b) => {
         const left = _rankOf(b);
         const right = _rankOf(a);
@@ -42,8 +20,6 @@ export function groupThreadsByRecency(threads, now) {
     });
     for (const thread of ordered) {
         const at = Date.parse(thread.updated_at);
-        // An unparseable or future stamp is described honestly rather than
-        // being filed under a day it did not happen.
         const label = Number.isNaN(at) || at >= startOfToday
             ? "Today"
             : at >= startOfYesterday
@@ -64,18 +40,10 @@ export function groupThreadsByRecency(threads, now) {
         threads: bucketed,
     }));
 }
-/** A thread's place on the timeline, as a number the comparator can always
- * subtract. A stamp that will not parse ranks above every real one. */
 function _rankOf(thread) {
     const at = Date.parse(thread.updated_at);
     return Number.isNaN(at) ? Number.POSITIVE_INFINITY : at;
 }
-/**
- * The history body: the one command, then the conversations under their
- * recency headings. Shared verbatim between the rail and the drawer —
- * they are the same list at two densities, and the day a phone's history
- * diverges from a desk's is the day one of them is wrong.
- */
 export function ThreadHistory({ threads, activeThreadId, onSelectThread, onNewConversation, touch = false, safeAreaBottom = true, }) {
     const groups = groupThreadsByRecency(threads, new Date());
     return (_jsxs("div", { className: "tf:flex tf:min-h-0 tf:flex-1 tf:flex-col", children: [_jsx("div", { className: "tf:shrink-0 tf:px-2 tf:pb-1", children: _jsxs(TfButton, { variant: touch ? "rowActionTouch" : "rowAction", onClick: onNewConversation, children: [_jsx(ComposeIcon, {}), "New conversation"] }) }), _jsx("div", { className: cx("tf:flex tf:min-h-0 tf:flex-1 tf:flex-col tf:overflow-y-auto tf:px-2", safeAreaBottom
@@ -84,10 +52,6 @@ export function ThreadHistory({ threads, activeThreadId, onSelectThread, onNewCo
                                         onSelectThread(thread);
                                     }, children: _jsx("span", { className: "tf:truncate", children: thread.title }) }) }, thread.id))) })] }, group.label)))) })] }));
 }
-// The house empty-state silhouette at rail scale: centred, a line that
-// names the state and a line that says what fills it. No action — the
-// only one there is sits 40px above this.
 function NoConversationsYet() {
     return (_jsxs("div", { className: "tf:my-auto tf:flex tf:flex-col tf:items-center tf:gap-1 tf:px-4 tf:py-6 tf:text-center", children: [_jsx("p", { className: "tf:text-tf-label tf:font-medium", children: "No conversations yet" }), _jsx("p", { className: "tf:text-tf-label tf:text-tf-muted-foreground", children: "Your chats show up here." })] }));
 }
-//# sourceMappingURL=thread-list.js.map

package/dist/components/tool-arguments-summary.js

@@ -5,35 +5,10 @@ const MAX_VISIBLE_ROWS = 8;
 const LONG_TEXT_CHARS = 120;
 const TEXT_PREVIEW_CHARS = 320;
 const ARRAY_PREVIEW_ITEMS = 4;
-// The section chrome, hoisted so the list stays a greppable literal: the
-// tool-view card vocabulary (tool-views/parts-classes.ts) — a hairline
-// card, a "Request" caption, property rows — so the rung-4 reading is a
-// property card like every other view in the row body. No height floor:
-// the card grows to its rows and never scrolls the transcript twice.
 const SECTION_CLASSES = `tf:flex tf:flex-col ${CARD_CLASS}`;
-/**
- * The resolution ladder's rung 4 (tool-views.md): the package default
- * view, over the bounded argument reading below. An INPUT reading by
- * design — it ignores `result` entirely, so an unknown customer tool
- * never grows an inferred result card or a raw output dump (TVC-111).
- * Deterministic like the reading it wraps: two identical calls render
- * byte-identical output, with no clocks and no locale. Its one mount
- * site is the slot's terminal in the tool row's body, where it wears
- * the one card vocabulary every tool view paints with.
- */
 export function DefaultToolView(props) {
     return _jsx(ToolArgumentsSummary, { arguments: props.call.args });
 }
-/**
- * A deterministic, semantics-free reading of arbitrary tool arguments —
- * general-purpose input furniture (the DOM hooks below keep their
- * approval-card-era names because styles.css and the geometry spec
- * select them). It never chooses a domain component and never prints
- * raw JSON: records become bounded field rows, long strings become a
- * two-line excerpt, and opaque structures become honest type/count
- * summaries. Determinism is contract: Object.keys().sort() at both
- * levels, no clocks, and the one locale call pinned to "en-US".
- */
 function ToolArgumentsSummary({ arguments: toolArguments, }) {
     const rows = _summaryRowsOf(toolArguments);
     if (rows.length === 0) {
@@ -112,4 +87,3 @@ function _isScalar(value) {
 function _scalarTextOf(value) {
     return value === null ? "null" : String(value);
 }
-//# sourceMappingURL=tool-arguments-summary.js.map