@teaflask/assistant 0.0.0 → 0.3.0

package/dist/components/scroll-follow-guards.js

@@ -0,0 +1,231 @@
+"use client";
+import { useEffect } from "react";
+import { useStickToBottomContext, } from "use-stick-to-bottom";
+// Repairs to use-stick-to-bottom's follow contract, all through its
+// public context — no fork, no patched internals. The library observes
+// only its CONTENT element and trusts its own scroll handler for
+// escapes AND re-engages; the three holes that leaves, and each
+// guard's reasoning, are docs/scroll-follow-guards.md. stopScroll() is
+// the library's complete escape primitive: it sets escapedFromLock and
+// clears isAtBottom, which aborts any in-flight follow.
+// Accumulated upward travel that counts as the visitor taking over
+// (guard 3): above the per-frame jitter a horizontal trackpad pan chains
+// into the transcript (reset every mid-stream growth frame), below the
+// smallest deliberate gesture (an arrow key is ~40px, PageUp a viewport).
+const TAKEOVER_TRAVEL_PX = 16;
+export function ScrollFollowGuards() {
+    const { scrollRef, state, stopScroll, scrollToBottom } = useStickToBottomContext();
+    useEffect(() => {
+        const scrollElement = scrollRef.current;
+        if (scrollElement === null) {
+            return;
+        }
+        const teardowns = [
+            _installShrinkRefollow(scrollElement, state, scrollToBottom),
+            _installWheelEscape(scrollElement, state, stopScroll),
+            _installTravelGuards(scrollElement, state, stopScroll, scrollToBottom),
+        ];
+        return () => {
+            for (const teardown of teardowns) {
+                teardown();
+            }
+        };
+        // Every dependency is identity-stable in the library (state is a
+        // mount-scoped memo; the callbacks close over stable refs), so this
+        // installs once per mounted scroller.
+    }, [scrollRef, scrollToBottom, state, stopScroll]);
+    return null;
+}
+// Guard 1 — viewport shrink re-follow, keyed to the SCROLL element's
+// height so content settles never trip it. state.isAtBottom is the
+// ONLY flag consulted (escapedFromLock sits stale-true on the escape
+// → jump → follow path). The landing write is synchronous — after two
+// rAFs the transcript is at its bottom — and goes through the
+// library's state.scrollTop setter, never the raw property (it forces
+// scroll-behavior:auto and records the echo in ignoreScrollToTop);
+// the trailing scrollToBottom keeps the library's bookkeeping coherent.
+function _installShrinkRefollow(scrollElement, state, scrollToBottom) {
+    // The follow-liveness proof. PREMISE: guard 1 may re-land a reader
+    // only on a page whose clock advances across frames — under a pinned
+    // clock the library's wait:true follows never complete and
+    // state.isAtBottom sits stale-true at the top of history. The probe
+    // reads Date.now() across frames and nothing else (never a follow's
+    // settlement, never a write). A shrink seen before the proof is
+    // remembered, not dropped: both paths that reach it are in
+    // docs/scroll-follow-guards.md; the latch counts are in the
+    // scroll-follow guard latch measurement record.
+    const clockStart = Date.now();
+    let clockProven = false;
+    let shrinkPendingProof = false;
+    const landAtBottom = () => {
+        state.scrollTop = scrollElement.scrollHeight - scrollElement.clientHeight;
+        void scrollToBottom({
+            animation: "instant",
+            wait: true,
+            preserveScrollPosition: true,
+        });
+    };
+    let proofFrame = requestAnimationFrame(function proveClock() {
+        if (Date.now() > clockStart) {
+            clockProven = true;
+            // The reader must still be followed at flush time — an escape
+            // between the remembered shrink and the proof wins.
+            if (shrinkPendingProof && state.isAtBottom) {
+                shrinkPendingProof = false;
+                landAtBottom();
+            }
+            return;
+        }
+        proofFrame = requestAnimationFrame(proveClock);
+    });
+    let lastClientHeight = null;
+    const observer = new ResizeObserver(() => {
+        const height = scrollElement.clientHeight;
+        const previousHeight = lastClientHeight;
+        lastClientHeight = height;
+        const viewportShrank = previousHeight !== null && height < previousHeight;
+        if (!viewportShrank || !state.isAtBottom) {
+            return;
+        }
+        // The proof's verdict: until the clock is proven, isAtBottom is
+        // not honest and no re-land is safe — a shrink that beats the
+        // first proving frame is remembered, never dropped.
+        if (!clockProven) {
+            shrinkPendingProof = true;
+            return;
+        }
+        landAtBottom();
+    });
+    observer.observe(scrollElement);
+    return () => {
+        cancelAnimationFrame(proofFrame);
+        observer.disconnect();
+    };
+}
+// Guard 2 — the wheel escape, minus the library's dead zone (it bails
+// unless the first overflow:auto ancestor IS the scroller). We escape
+// unless something between the pointer and the scroller will consume
+// the upward wheel — an inner scroller that can still scroll up; one
+// at its own top chains the wheel to the transcript, so it escapes.
+function _installWheelEscape(scrollElement, state, stopScroll) {
+    const handleWheel = (event) => {
+        // Vertical dominance, not just a negative deltaY: a trackpad's
+        // horizontal pan carries small negative deltaY jitter beside a large
+        // deltaX, and panning a long code line mid-stream must not release
+        // the lock. |deltaY| > |deltaX| is the browser's own axis call.
+        const wheelingUp = event.deltaY < 0 && Math.abs(event.deltaY) > Math.abs(event.deltaX);
+        const transcriptOverflows = scrollElement.scrollHeight > scrollElement.clientHeight;
+        if (wheelingUp &&
+            transcriptOverflows &&
+            state.animation?.ignoreEscapes !== true &&
+            !wheelConsumedBelow(event.target, scrollElement)) {
+            stopScroll();
+        }
+    };
+    scrollElement.addEventListener("wheel", handleWheel, {
+        passive: true,
+        capture: true,
+    });
+    return () => {
+        scrollElement.removeEventListener("wheel", handleWheel, {
+            capture: true,
+        });
+    };
+}
+// Guards 3 and 4 — the non-wheel escape and its mirror, which the
+// library cannot deliver from inside its resizeDifference gate.
+// Capture on an ANCESTOR is load-bearing: scroll events capture-
+// descend, and the library's at-target listener synchronously clears
+// ignoreScrollToTop — running before it is the only way to tell its
+// writes from the visitor's. The ancestor is the scroller's root node,
+// not window: scroll is neither bubbling nor composed, so in the
+// embeds' open shadow root a window listener would never fire.
+//
+// Escape (guard 3): accumulated upward travel that is not a library
+// write, not the browser clamping under a content shrink, and not
+// overscroll settle at the bottom. The ACCUMULATOR (not a per-event
+// threshold) is what lets chained pan jitter never accrue — the
+// follow resets it every growth frame — while a slow drag still
+// crosses TAKEOVER_TRAVEL_PX within a move or two.
+//
+// Re-engage (guard 4): a downward move that CLOSES the gap and LANDS
+// at the bottom while unfollowed. The landing gate (bottomGap <= 1)
+// is load-bearing: our scrollToBottom repositions, and doing so
+// anywhere inside the near-bottom band would fight a scrollbar or
+// touch drag (snap down, pointer pulls up, guard 3 escapes, repeat);
+// at bottomGap <= 1 it is a pure re-arm. "Closes the gap" rules out
+// scroll anchoring, which bumps scrollTop while holding the gap.
+function _installTravelGuards(scrollElement, state, stopScroll, scrollToBottom) {
+    let lastScrollTop = scrollElement.scrollTop;
+    let lastScrollHeight = scrollElement.scrollHeight;
+    let lastBottomGap = scrollElement.scrollHeight -
+        scrollElement.clientHeight -
+        scrollElement.scrollTop;
+    let upwardTravel = 0;
+    const handleScroll = (event) => {
+        if (event.target !== scrollElement) {
+            return;
+        }
+        const { scrollTop, scrollHeight, clientHeight } = scrollElement;
+        const bottomGap = scrollHeight - clientHeight - scrollTop;
+        const previousTop = lastScrollTop;
+        const previousScrollHeight = lastScrollHeight;
+        const previousBottomGap = lastBottomGap;
+        lastScrollTop = scrollTop;
+        lastScrollHeight = scrollHeight;
+        lastBottomGap = bottomGap;
+        const libraryWroteIt = scrollTop === state.ignoreScrollToTop;
+        const movedUp = scrollTop < previousTop;
+        const movedDown = scrollTop > previousTop;
+        const contentShrankUnderUs = scrollHeight < previousScrollHeight || state.resizeDifference < 0;
+        const overscrollSettleAtBottom = bottomGap <= 1;
+        if (libraryWroteIt || movedDown) {
+            upwardTravel = 0;
+        }
+        if (movedUp &&
+            !libraryWroteIt &&
+            !contentShrankUnderUs &&
+            !overscrollSettleAtBottom &&
+            state.animation?.ignoreEscapes !== true) {
+            upwardTravel += previousTop - scrollTop;
+            if (upwardTravel > TAKEOVER_TRAVEL_PX) {
+                upwardTravel = 0;
+                stopScroll();
+                return;
+            }
+        }
+        const closingTheGap = movedDown && previousBottomGap - bottomGap > 1;
+        if (!state.isAtBottom && closingTheGap && bottomGap <= 1) {
+            void scrollToBottom({ animation: "instant" });
+        }
+    };
+    const scrollRoot = scrollElement.getRootNode();
+    scrollRoot.addEventListener("scroll", handleScroll, {
+        passive: true,
+        capture: true,
+    });
+    return () => {
+        scrollRoot.removeEventListener("scroll", handleScroll, {
+            capture: true,
+        });
+    };
+}
+// True when an element between the wheel's target and the scroller
+// (inclusive of the target) would consume an upward wheel itself: it can
+// still scroll up AND its overflow-y actually scrolls. Mirrors native
+// scroll chaining — the browser only hands the wheel to the transcript
+// once every inner scroller is at its top. The geometry reads come first
+// so getComputedStyle stays off the hot path.
+function wheelConsumedBelow(target, scrollElement) {
+    let element = target instanceof Element ? target : null;
+    while (element !== null && element !== scrollElement) {
+        const canStillScrollUp = element.scrollTop > 0 && element.scrollHeight > element.clientHeight;
+        if (canStillScrollUp &&
+            ["auto", "scroll", "overlay"].includes(getComputedStyle(element).overflowY)) {
+            return true;
+        }
+        element = element.parentElement;
+    }
+    return false;
+}
+//# sourceMappingURL=scroll-follow-guards.js.map

package/dist/components/scroll-follow-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-follow-guards.js","sourceRoot":"","sources":["../../src/components/scroll-follow-guards.tsx"],"names":[],"mappings":"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"}

package/dist/components/served-suggestions.d.ts

@@ -0,0 +1,10 @@
+import type { ServedSuggestionsConfig } from "../contract/assistant-config.js";
+import type { AssistantSuggestion } from "./conversation-view.js";
+/**
+ * The longest-prefix route's set, or the default set when no route
+ * covers the path. A matched route's EMPTY set is honored — it authors
+ * "no suggestions on this route" — which is why this never falls back
+ * from a match.
+ */
+export declare function servedSuggestionsForPath(config: ServedSuggestionsConfig, pathname: string): readonly AssistantSuggestion[];
+//# sourceMappingURL=served-suggestions.d.ts.map

package/dist/components/served-suggestions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"served-suggestions.d.ts","sourceRoot":"","sources":["../../src/components/served-suggestions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,MAAM,GACf,SAAS,mBAAmB,EAAE,CAKhC"}

package/dist/components/served-suggestions.js

@@ -0,0 +1,46 @@
+// Picking the served suggestion set for the page the visitor is on.
+// Lives beside the drawer body so it rides the drawer's lazy chunk —
+// the eager element shell never pays for it. Matching is computed per
+// render from the pathname the caller reads; the package deliberately
+// holds no route subscription.
+/**
+ * The longest-prefix route's set, or the default set when no route
+ * covers the path. A matched route's EMPTY set is honored — it authors
+ * "no suggestions on this route" — which is why this never falls back
+ * from a match.
+ */
+export function servedSuggestionsForPath(config, pathname) {
+    const route = _longestCoveringRoute(config.routes ?? [], pathname);
+    const items = route === null ? (config.default ?? []) : (route.suggestions ?? []);
+    return items.map((item) => ({ prompt: item.prompt, kind: item.kind }));
+}
+function _longestCoveringRoute(routes, pathname) {
+    let covering = null;
+    let coveringLength = -1;
+    for (const route of routes) {
+        const fence = _fenceOf(route.path_prefix);
+        if (!_aFenceCovers(fence, pathname)) {
+            continue;
+        }
+        // Strictly longer wins; a duplicate-length tie keeps the first
+        // (duplicates are unstorable anyway — the write gate rejects them).
+        if (fence.length > coveringLength) {
+            covering = route;
+            coveringLength = fence.length;
+        }
+    }
+    return covering;
+}
+// The navigate fence's grammar (mirrors _a_prefix_covers in the backend):
+// segment-aware — "/docs" covers "/docs/x", never "/docsy"; a trailing
+// slash on the prefix is cosmetic; an all-slash prefix covers everything.
+function _fenceOf(prefix) {
+    return prefix.replace(/\/+$/, "");
+}
+function _aFenceCovers(fence, pathname) {
+    if (fence === "") {
+        return true;
+    }
+    return pathname === fence || pathname.startsWith(fence + "/");
+}
+//# sourceMappingURL=served-suggestions.js.map

package/dist/components/served-suggestions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"served-suggestions.js","sourceRoot":"","sources":["../../src/components/served-suggestions.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,qEAAqE;AACrE,sEAAsE;AACtE,sEAAsE;AACtE,+BAA+B;AAQ/B;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAA+B,EAC/B,QAAgB;IAEhB,MAAM,KAAK,GAAG,qBAAqB,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,QAAQ,CAAC,CAAC;IACnE,MAAM,KAAK,GACT,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;IACtE,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,SAAS,qBAAqB,CAC5B,MAAyC,EACzC,QAAgB;IAEhB,IAAI,QAAQ,GAAkC,IAAI,CAAC;IACnD,IAAI,cAAc,GAAG,CAAC,CAAC,CAAC;IACxB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC1C,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC;YACpC,SAAS;QACX,CAAC;QACD,+DAA+D;QAC/D,oEAAoE;QACpE,IAAI,KAAK,CAAC,MAAM,GAAG,cAAc,EAAE,CAAC;YAClC,QAAQ,GAAG,KAAK,CAAC;YACjB,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC;QAChC,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,0EAA0E;AAC1E,uEAAuE;AACvE,0EAA0E;AAC1E,SAAS,QAAQ,CAAC,MAAc;IAC9B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACpC,CAAC;AAED,SAAS,aAAa,CAAC,KAAa,EAAE,QAAgB;IACpD,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,KAAK,KAAK,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;AAChE,CAAC"}

package/dist/components/slot-boundary.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from "react";
+export declare function HostSlotBoundary({ slot, fallback, children, }: {
+    /** Which slot this isolates — names the failure in the console line. */
+    slot: string;
+    fallback: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The fill decision, made INSIDE the boundary: the render callback runs
+ *  here so a synchronous throw is caught, and a null/undefined return
+ *  falls through to the same package default the boundary would fall back
+ *  to — one default, two routes to it.
+ *
+ *  THE KEYING LAW: frame behavior attached to a slot must key on the fill
+ *  having ACTUALLY RENDERED, never on the prop having been supplied —
+ *  both fallback routes land on the package default, which carries its
+ *  own signals, and a prop-keyed extra would double them. The per-slot
+ *  enumeration is in docs/transcript-surfaces.md, "The keying law". The
+ *  toolRow annex (filledAnnex, the status word) weakens no isolation law:
+ *  fill rendered → the annex, package-rendered and unreachable by the
+ *  fill; null return or throw → the package ToolRow's own state pill. */
+export declare function SlotOrDefault({ render, fallback, filledAnnex, }: {
+    render: () => ReactNode;
+    fallback: ReactNode;
+    /** Package-owned content rendered beside the fill exactly when the
+     *  fill rendered — never beside the fallback. */
+    filledAnnex?: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=slot-boundary.d.ts.map

package/dist/components/slot-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-boundary.d.ts","sourceRoot":"","sources":["../../src/components/slot-boundary.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAclD,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAaA;AAoCD;;;;;;;;;;;;yEAYyE;AACzE,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,QAAQ,EACR,WAAW,GACZ,EAAE;IACD,MAAM,EAAE,MAAM,SAAS,CAAC;IACxB,QAAQ,EAAE,SAAS,CAAC;IACpB;qDACiD;IACjD,WAAW,CAAC,EAAE,SAAS,CAAC;CACzB,+BAcA"}

package/dist/components/slot-boundary.js

@@ -0,0 +1,62 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Component } from "react";
+import { hostFillDeclines } from "../core/host-fill.js";
+import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
+// The host-slot isolation wrapper: every host-supplied slot on
+// AssistantTranscript EXCEPT `input` mounts inside one of these (the
+// input-region rule — that slot is deliberately unbounded), so a throwing
+// fill costs its own slot and nothing else. Two laws by construction: the
+// FALLBACK is the package's own rendering, rendered by this boundary and
+// never as a sibling inside the children (mandatory frame elements render
+// OUTSIDE it at the call site), so a broken fill cannot take the default
+// with it; and a slot that threw is latched for that mount — a new row's key gets a fresh boundary.
+export function HostSlotBoundary({ slot, fallback, children, }) {
+    // Tolerant on purpose: agent-mode hosts (the run viewer, the playground)
+    // mount with no session provider; the console line is the report there.
+    const session = useOptionalAssistantSession();
+    return (_jsx(_SlotCatch, { slot: slot, fallback: fallback, reportError: session?.reportError, children: children }));
+}
+class _SlotCatch extends Component {
+    state = { failed: false };
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    componentDidCatch(error) {
+        const shaped = error instanceof Error ? error : new Error(String(error));
+        // The host's observer hears it, and the console names the slot for
+        // whoever is actually debugging the page.
+        this.props.reportError?.(shaped);
+        console.error(`[teaflask-assistant] The host "${this.props.slot}" slot threw; the package rendering took over.`, shaped);
+    }
+    render() {
+        if (this.state.failed) {
+            return _jsx(_Fragment, { children: this.props.fallback });
+        }
+        return _jsx(_Fragment, { children: this.props.children });
+    }
+}
+/** The fill decision, made INSIDE the boundary: the render callback runs
+ *  here so a synchronous throw is caught, and a null/undefined return
+ *  falls through to the same package default the boundary would fall back
+ *  to — one default, two routes to it.
+ *
+ *  THE KEYING LAW: frame behavior attached to a slot must key on the fill
+ *  having ACTUALLY RENDERED, never on the prop having been supplied —
+ *  both fallback routes land on the package default, which carries its
+ *  own signals, and a prop-keyed extra would double them. The per-slot
+ *  enumeration is in docs/transcript-surfaces.md, "The keying law". The
+ *  toolRow annex (filledAnnex, the status word) weakens no isolation law:
+ *  fill rendered → the annex, package-rendered and unreachable by the
+ *  fill; null return or throw → the package ToolRow's own state pill. */
+export function SlotOrDefault({ render, fallback, filledAnnex, }) {
+    const filled = render();
+    // THE FALL-THROUGH RULE (core/host-fill.ts): null, undefined and both
+    // booleans decline; renderable emptiness is the host's deliberate
+    // choice of empty content and counts as filled.
+    if (hostFillDeclines(filled)) {
+        return _jsx(_Fragment, { children: fallback });
+    }
+    return (_jsxs(_Fragment, { children: [filled, filledAnnex] }));
+}
+//# sourceMappingURL=slot-boundary.js.map

package/dist/components/slot-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-boundary.js","sourceRoot":"","sources":["../../src/components/slot-boundary.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,SAAS,EAAkB,MAAM,OAAO,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAE/E,+DAA+D;AAC/D,qEAAqE;AACrE,0EAA0E;AAC1E,0EAA0E;AAC1E,yEAAyE;AACzE,0EAA0E;AAC1E,yEAAyE;AACzE,oGAAoG;AAEpG,MAAM,UAAU,gBAAgB,CAAC,EAC/B,IAAI,EACJ,QAAQ,EACR,QAAQ,GAMT;IACC,yEAAyE;IACzE,wEAAwE;IACxE,MAAM,OAAO,GAAG,2BAA2B,EAAE,CAAC;IAC9C,OAAO,CACL,KAAC,UAAU,IACT,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,OAAO,EAAE,WAAW,YAEhC,QAAQ,GACE,CACd,CAAC;AACJ,CAAC;AAED,MAAM,UAAW,SAAQ,SAQxB;IACC,KAAK,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAE1B,MAAM,CAAC,wBAAwB;QAC7B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAC1B,CAAC;IAED,iBAAiB,CAAC,KAAc;QAC9B,MAAM,MAAM,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACzE,mEAAmE;QACnE,0CAA0C;QAC1C,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC;QACjC,OAAO,CAAC,KAAK,CACX,kCAAkC,IAAI,CAAC,KAAK,CAAC,IAAI,gDAAgD,EACjG,MAAM,CACP,CAAC;IACJ,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACtB,OAAO,4BAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAI,CAAC;QACpC,CAAC;QACD,OAAO,4BAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAI,CAAC;IACpC,CAAC;CACF;AAED;;;;;;;;;;;;yEAYyE;AACzE,MAAM,UAAU,aAAa,CAAC,EAC5B,MAAM,EACN,QAAQ,EACR,WAAW,GAOZ;IACC,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,sEAAsE;IACtE,kEAAkE;IAClE,gDAAgD;IAChD,IAAI,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,OAAO,4BAAG,QAAQ,GAAI,CAAC;IACzB,CAAC;IACD,OAAO,CACL,8BACG,MAAM,EACN,WAAW,IACX,CACJ,CAAC;AACJ,CAAC"}

package/dist/components/streaming-states.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from "react";
+export declare function TypingIndicator(): import("react").JSX.Element;
+export declare function ShimmerText({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function Spinner({ label, }: {
+    /** The state the motion stands for — always rendered as visible text,
+     *  so the spinner never spins wordlessly and reduced motion loses
+     *  nothing. */
+    label: string;
+}): import("react").JSX.Element;
+export declare function StreamingLine({ children }: {
+    children: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=streaming-states.d.ts.map

package/dist/components/streaming-states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-states.d.ts","sourceRoot":"","sources":["../../src/components/streaming-states.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAgCvC,wBAAgB,eAAe,gCAa9B;AAED,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,+BAeA;AAED,wBAAgB,OAAO,CAAC,EACtB,KAAK,GACN,EAAE;IACD;;mBAEe;IACf,KAAK,EAAE,MAAM,CAAC;CACf,+BAsBA;AAED,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,+BAM/D"}

package/dist/components/streaming-states.js

@@ -0,0 +1,43 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { cx } from "./primitives/cx.js";
+// The adopted register — bake-off 2026-07-30 (assistant-ui): a single pulsing dot where the next
+// message will land — the ChatGPT idiom assistant-ui ships as its
+// working indicator — and muted status text rendered as a moving gradient
+// (the active-reasoning treatment; its animation lives in styles.css under
+// [data-tf-shimmer-highlight]).
+//
+// THE MOTION PRIMITIVES (contract law 11). This module owns the
+// migration's two motion primitives, and they are the only two:
+//
+//   - ShimmerText — THE active-text shimmer. Every surface whose words
+//     move while work is live (fold headlines, process-row labels,
+//     subagent presence) renders through it; nothing forks its markup
+//     or keyframes (TVC-013 pins the fold, TVC-100 its reduced-motion
+//     collapse).
+//   - Spinner — THE indeterminate spinner, under [data-tf-spinner]. Its
+//     label is REQUIRED and always visible: the hook is never valueless,
+//     so reduced motion always leaves state text behind (TVC-101).
+//     Today's only surface is the decision cards' submitting beat
+//     ("Sending…"); run-state liveness everywhere else is ShimmerText.
+//
+// Both collapse under BOTH switches — the OS prefers-reduced-motion query
+// and the host kill switch (data-reduce-motion="true" on any ancestor; the
+// script-tag element reflects it across its shadow boundary) — and both
+// are proven inside the custom element's constructed-stylesheet shadow
+// root under a strict CSP (TVC-102). A lane needing motion beyond these
+// must mint its own reduced-motion law; three shimmer implementations is a
+// failure of contract law 11.
+export function TypingIndicator() {
+    return (_jsx("span", { "data-tf-working-dot": "", className: "tf:animate-tf-pulse tf:text-tf-body tf:text-tf-foreground tf:motion-reduce:animate-none", role: "status", "aria-label": "The assistant is working", children: "●" }));
+}
+export function ShimmerText({ children, className, }) {
+    return (_jsxs("span", { "data-tf-shimmer-text": "", className: cx("tf:inline-grid", className), children: [_jsx("span", { "data-tf-shimmer-base": "", className: "tf:col-start-1 tf:row-start-1", children: children }), _jsx("span", { "data-tf-shimmer-highlight": "", "aria-hidden": true, className: "tf:col-start-1 tf:row-start-1", children: children })] }));
+}
+export function Spinner({ label, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("svg", { viewBox: "0 0 16 16", "aria-hidden": "true", "data-tf-spinner": "", className: "tf:size-3.5 tf:shrink-0 tf:animate-tf-spin tf:motion-reduce:animate-none", children: _jsx("path", { d: "M8 1.5a6.5 6.5 0 1 1-6.5 6.5", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round" }) }), _jsx("span", { children: label })] }));
+}
+export function StreamingLine({ children }) {
+    return (_jsx(ShimmerText, { className: "tf:text-tf-label tf:text-tf-muted-foreground", children: children }));
+}
+//# sourceMappingURL=streaming-states.js.map

package/dist/components/streaming-states.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-states.js","sourceRoot":"","sources":["../../src/components/streaming-states.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAIb,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAExC,iGAAiG;AACjG,kEAAkE;AAClE,0EAA0E;AAC1E,2EAA2E;AAC3E,gCAAgC;AAChC,EAAE;AACF,gEAAgE;AAChE,gEAAgE;AAChE,EAAE;AACF,uEAAuE;AACvE,mEAAmE;AACnE,sEAAsE;AACtE,sEAAsE;AACtE,iBAAiB;AACjB,wEAAwE;AACxE,yEAAyE;AACzE,mEAAmE;AACnE,kEAAkE;AAClE,uEAAuE;AACvE,EAAE;AACF,0EAA0E;AAC1E,2EAA2E;AAC3E,wEAAwE;AACxE,uEAAuE;AACvE,wEAAwE;AACxE,2EAA2E;AAC3E,8BAA8B;AAE9B,MAAM,UAAU,eAAe;IAC7B,OAAO,CACL,sCAGsB,EAAE,EACtB,SAAS,EAAC,yFAAyF,EACnG,IAAI,EAAC,QAAQ,gBACF,0BAA0B,YAEpC,GAAG,GACC,CACR,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,EAC1B,QAAQ,EACR,SAAS,GAIV;IACC,OAAO,CACL,wCAA2B,EAAE,EAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,SAAS,CAAC,aACtE,uCAA2B,EAAE,EAAC,SAAS,EAAC,+BAA+B,YACpE,QAAQ,GACJ,EACP,4CAC4B,EAAE,uBAE5B,SAAS,EAAC,+BAA+B,YAExC,QAAQ,GACJ,IACF,CACR,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,EACtB,KAAK,GAMN;IACC,OAAO,CACL,8BACE,cACE,OAAO,EAAC,WAAW,iBACP,MAAM,qBAGF,EAAE,EAClB,SAAS,EAAC,0EAA0E,YAEpF,eACE,CAAC,EAAC,8BAA8B,EAChC,IAAI,EAAC,MAAM,EACX,MAAM,EAAC,cAAc,EACrB,WAAW,EAAC,KAAK,EACjB,aAAa,EAAC,OAAO,GACrB,GACE,EACN,yBAAO,KAAK,GAAQ,IACnB,CACJ,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,EAAE,QAAQ,EAAwB;IAC9D,OAAO,CACL,KAAC,WAAW,IAAC,SAAS,EAAC,8CAA8C,YAClE,QAAQ,GACG,CACf,CAAC;AACJ,CAAC"}

package/dist/components/subagent-count-pill.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+import { type ThreadDispatch } from "../contract/dispatches.js";
+import { type SubagentRosterEntry } from "../core/subagent-roster.js";
+export declare function SubagentCountPill({ dispatches, threadId, renderPreview, }: {
+    dispatches: ReadonlyMap<number, ThreadDispatch>;
+    threadId?: string;
+    /** Deterministic preview seam for the package screenshot fixture. */
+    renderPreview?: (entry: SubagentRosterEntry) => ReactNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=subagent-count-pill.d.ts.map

package/dist/components/subagent-count-pill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-count-pill.d.ts","sourceRoot":"","sources":["../../src/components/subagent-count-pill.tsx"],"names":[],"mappings":"AAiBA,OAAO,EAAU,KAAK,SAAS,EAAkB,MAAM,OAAO,CAAC;AAE/D,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAOL,KAAK,mBAAmB,EACzB,MAAM,4BAA4B,CAAC;AAoBpC,wBAAgB,iBAAiB,CAAC,EAChC,UAAU,EACV,QAAQ,EACR,aAAa,GACd,EAAE;IAID,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,SAAS,CAAC;CAC3D,sCAuGA"}