@teaflask/assistant 0.3.0 → 0.7.0

package/dist/components/tool-call-rows.js

@@ -11,59 +11,22 @@ import { QuestionPanel } from "./question-panel.js";
 import { HostSlotBoundary, SlotOrDefault } from "./slot-boundary.js";
 import { SurfaceBoundary } from "./surface-boundary.js";
 import { ToolRow } from "./tool-row.js";
-// A HITL-gated call pauses the turn right here. In the shipping shelf
-// composition the actionable card lives in the suspension slot and this
-// row keeps the compact chronology: the "Needs input" pill while the
-// decision pends, then only the row's own state — no settled prose line
-// renders (no meta-receipt rows; the card's footer is the outcome's other
-// surface). Shelf-less hosts mount the cards inline beneath the row
-// (anchored via tool_call_id). An answered ask collapses further either
-// way: once its result carries a settled answer its tool view becomes the
-// Q&A record.
 export function ToolCallRows({ row, cards, inCurrentTurn = false, decisionSurfacesInShelf = false, toolRow, }) {
     const { cards: elicitationCards } = useContext(ElicitationsContext);
-    // Answers stay inspectable in the normal tool view. The durable
-    // result also suppresses the temporary inline question panel.
     const settledQuestions = settledQuestionsReceiptOf(row.toolName, row.argsText, row.result);
-    // Which decisions belong to THIS row: in the shelf composition the
-    // join keys on the RENDERED ROW (tool call id), never the marker-time
-    // `anchored` flag — after a page reload during a pause every card is
-    // a marker-time orphan (no TOOL_CALL_START replayed) while its call's
-    // row is right here, and its settled state must land on it, never
-    // silently vanish (approval-inbox.ts's own rule). The shelf-less mode
-    // keeps the historical anchored selection, which also decides card
-    // MOUNTING there.
     const anchoredApprovals = decisionSurfacesInShelf
         ? cards.filter((card) => card.toolCallId === row.toolCallId)
         : anchoredCardsFor(cards, row.toolCallId);
     const anchoredElicitations = decisionSurfacesInShelf
         ? elicitationCards.filter((card) => card.toolCallId === row.toolCallId)
         : anchoredElicitationsFor(elicitationCards, row.toolCallId);
-    // The row itself says it is the one waiting (state on the affected
-    // operation); answered and stale cards are receipts and mark nothing.
-    // The pill keeps the AWAITING spelling and deliberately does NOT share
-    // the hold's predicate: waiting ends with the decision, the hold with the turn.
     const awaitingInput = settledQuestions === null &&
         _awaitsMemberDecision(anchoredApprovals, anchoredElicitations);
     const stateWord = _mandatoryStateWordOf(row.state, awaitingInput);
-    // The row's hold arm (the durable re-derivation): the row model's
-    // decisionBearing — the replayed marker anchor — is the arm that
-    // survives the card stores' pruning (the gated call's
-    // result, RUN_ERROR, the turn's settle) and a reload; the live
-    // anchored cards are the complement for a REST-hydrated pause whose
-    // stream never ran and for fixture scenes that pose cards without
-    // histories. Never state: both arms are derivations.
     const decisionBearing = row.decisionBearing === true ||
         anchoredApprovals.length > 0 ||
         anchoredElicitations.length > 0;
-    // NOTE: no settled decision statements render here or anywhere else in
-    // the transcript (the meta-receipt rows, the audit-visibility lines among
-    // them, are deleted): a consent outcome's surfaces are the decision
-    // card's own footer and this row's state pill. Do not restore the prose
-    // lines as a bug fix.
     const view = _toolViewOf(row);
-    // Stored asks predate the registered question view. Upgrade their
-    // presentation without rewriting history or overriding an authored view.
     if (settledQuestions !== null && view.display?.view === undefined) {
         view.display = {
             ...view.display,
@@ -72,40 +35,12 @@ export function ToolCallRows({ row, cards, inCurrentTurn = false, decisionSurfac
         };
     }
     const packageToolRow = (_jsx(ToolRow, { view: view, awaitingInput: awaitingInput, decisionBearing: decisionBearing, inCurrentTurn: inCurrentTurn }));
-    return (_jsxs(_Fragment, { children: [toolRow === undefined ? (packageToolRow) : (_jsx(HostSlotBoundary, { slot: "toolRow", fallback: packageToolRow, children: _jsx(SlotOrDefault, { render: () => toolRow({ row, view, awaitingInput }), fallback: packageToolRow, 
-                    // Mandatory status (non-negotiable): a filled toolRow
-                    // cannot mute an error, an interruption, a refusal, a
-                    // member's denial, or a pending decision — package-rendered
-                    // beside the fill, a sibling the fill cannot reach. Keyed
-                    // on the fill having RENDERED, never on the prop being
-                    // supplied: on both fallback routes — a null return, a
-                    // throw — the package ToolRow's own state pill carries the
-                    // status, and this word beside it would make a screen
-                    // reader hear the state twice.
-                    filledAnnex: stateWord !== null ? (_jsx("span", { className: "tf:sr-only", "data-tf-tool-state": row.state, children: stateWord })) : undefined }) })), decisionSurfacesInShelf || settledQuestions !== null ? null : (_jsxs(_Fragment, { children: [anchoredApprovals.map((card) => (
-                    // Adjacency PLACES the banner under its call's row on this
-                    // shelf-less path; the banner reads only the card model.
-                    // Per-card boundary: a poisoned card degrades one banner.
-                    _jsx(SurfaceBoundary, { surface: "approval-card", children: _jsx(ApprovalCard, { card: card }) }, card.interruptId))), anchoredElicitations.map((card) => (_jsx(SurfaceBoundary, { surface: "question-panel", children: _jsx(QuestionPanel, { card: card }) }, card.interruptId)))] }))] }));
+    return (_jsxs(_Fragment, { children: [toolRow === undefined ? (packageToolRow) : (_jsx(HostSlotBoundary, { slot: "toolRow", fallback: packageToolRow, children: _jsx(SlotOrDefault, { render: () => toolRow({ row, view, awaitingInput }), fallback: packageToolRow, filledAnnex: stateWord !== null ? (_jsx("span", { className: "tf:sr-only", "data-tf-tool-state": row.state, children: stateWord })) : undefined }) })), decisionSurfacesInShelf || settledQuestions !== null ? null : (_jsxs(_Fragment, { children: [anchoredApprovals.map((card) => (_jsx(SurfaceBoundary, { surface: "approval-card", children: _jsx(ApprovalCard, { card: card }) }, card.interruptId))), anchoredElicitations.map((card) => (_jsx(SurfaceBoundary, { surface: "question-panel", children: _jsx(QuestionPanel, { card: card }) }, card.interruptId)))] }))] }));
 }
-/** The pending-decision judgement over one row's anchored cards. The
- *  SPELLING of "still waiting on the human" lives in ONE place
- *  (approvalAwaitsMember/elicitationAwaitsMember, core/suspension-queue.ts)
- *  because the row's "Needs input" pill (TVC-036) and the suspension
- *  queue must agree — and the fold's default openness
- *  (_groupAwaitsDecision, activity-rail.tsx) reads the same live
- *  pendency. The ROW's placement hold deliberately keys on ANCHORING,
- *  not awaiting (the decisionBearing derivation above): TVC-014's hold
- *  window is the turn, which outlives the pendency. */
 function _awaitsMemberDecision(anchoredApprovals, anchoredElicitations) {
     return (anchoredApprovals.some(approvalAwaitsMember) ||
         anchoredElicitations.some(elicitationAwaitsMember));
 }
-/** The frame's status word beside a host-filled toolRow — the same
- *  vocabulary the package pills wear (Failed; Not approved; Interrupted
- *  for cancelled and superseded alike; Declined; Needs input, TVC-036).
- *  Null for the quiet states: running and settled-clean carry no
- *  mandatory word. */
 function _mandatoryStateWordOf(state, awaitingInput) {
     if (state === "output-error") {
         return "Failed";
@@ -125,12 +60,6 @@ function _mandatoryStateWordOf(state, awaitingInput) {
     return null;
 }
 function _toolViewOf(row) {
-    // An offloaded call's "result" is the context offloader's model-facing
-    // replacement — retrieval guidance addressed to the model, storage
-    // reference lines — not the tool's output, so it is suppressed like the
-    // cancelled sentinel and the row renders the quiet shortened-result
-    // line instead. Errored and cancelled rows keep their existing stories:
-    // those states already suppress the output, and their panes win.
     const offloaded = row.offloaded &&
         row.errorText === undefined &&
         row.state !== "denied" &&
@@ -141,17 +70,7 @@ function _toolViewOf(row) {
         state: row.state,
         toolCallId: row.toolCallId,
         input: _prettyArgsOf(row.argsText),
-        // The raw argument text rides beside the pretty print: the
-        // presenter parses it into the tool-view call's `args`.
         argsText: row.argsText,
-        // A failed call shows its Error pane, not a Result pane. A cancelled
-        // call shows neither: its "result" is the model-facing cancellation
-        // text, and the row's own Interrupted pill carries the story (the
-        // meta-receipt rows beside it are deleted). A refused call likewise:
-        // the refusal envelope; the reason line carries the story. A denied
-        // call likewise: the same cancellation sentinel a cancel carries —
-        // the wire's stamp this state outranks — and the pill carries the
-        // story.
         output: row.errorText !== undefined ||
             row.state === "denied" ||
             row.state === "cancelled" ||
@@ -163,9 +82,6 @@ function _toolViewOf(row) {
         errorText: row.errorText,
         ...(row.refusalText !== undefined ? { refusalText: row.refusalText } : {}),
         display: row.display,
-        // The anchored schema REFERENCES ride through unwrapped: the
-        // presenter's identity law needs the same object per source, and the
-        // anchors map's first-wins merge already guarantees it.
         ...(row.schemas?.argsSchema !== undefined
             ? { argsSchema: row.schemas.argsSchema }
             : {}),
@@ -174,9 +90,6 @@ function _toolViewOf(row) {
             : {}),
     };
 }
-// The streamed arguments are JSON text, possibly mid-stream: parse when
-// whole (for the stable two-space print), pass through verbatim while
-// the tail is still arriving.
 function _prettyArgsOf(argsText) {
     if (argsText === "") {
         return "";
@@ -188,4 +101,3 @@ function _prettyArgsOf(argsText) {
         return argsText;
     }
 }
-//# sourceMappingURL=tool-call-rows.js.map

package/dist/components/tool-row.js

@@ -1,12 +1,5 @@
 "use client";
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-// The universal process-row grammar: a semantic operation mark
-// (operation-icons.tsx — identity stays visible in every state; completion
-// is quiet, never a universal tick), the headline in muted ink with a
-// shimmer sweep while running, an inline state pill for failure /
-// interruption / the door's refusal / a member's denial / awaiting-input,
-// a chevron; expanding indents the panes under the label column, no card
-// chrome. The row reads the RESOLVED presentation, never the raw display envelope.
 import {} from "../core/tool-call-display.js";
 import { toolCallPresentationOf } from "../core/tool-call-presentation.js";
 import { OperationMark, StatePill } from "./operation-icons.js";
@@ -15,17 +8,6 @@ import { ShimmerText } from "./streaming-states.js";
 import { useToolViewRegistry } from "./tool-view-registry-context.js";
 import { ToolViewIconSlot, ToolViewSlot } from "./tool-view-slot.js";
 import { humanFailureSentenceOf } from "./tool-views/view-dom.js";
-// Tool rows share the activity rail geometry (gap-3, ps-7 body). Answered
-// asks use the same geometry inside their work fold. Summary child positions
-// are contract: mark first, label second (TVC-050/051 measure exactly those
-// children); the pill and chevron follow. Row placement: a HOST-authored
-// view (rungs 1–2) or a decision holds the row open while its turn is
-// current and the call is running or settled clean; released to native at
-// the next user turn. A package built-in or the default reading never opens
-// a row — the host decided the tool was worth a view, the package did not —
-// and a failed, not-run or degraded (truncated, offloaded) row is closed
-// whatever it resolved: the pill names the state, the body is for the member
-// who asks.
 function heldOpenOf(view, toolView, decision) {
     const hostViewBearing = toolView.views.some((candidate) => candidate.rung <= 2);
     return (isCleanState(view.state) &&
@@ -39,10 +21,6 @@ function isCleanState(state) {
         state === "output-available");
 }
 export function ToolRow({ view, awaitingInput = false, decisionBearing, inCurrentTurn = false, }) {
-    // The resolved presentation: the single resolution point — this row
-    // reads slots, never the raw display envelope. The tool-view ladder's
-    // answer (tool-views.md) arrives as the toolView slot: the rung 1–3
-    // candidates plus the assembled call.
     const presentation = toolCallPresentationOf(view, useToolViewRegistry(), {
         awaitingDecision: awaitingInput,
     });
@@ -51,25 +29,6 @@ export function ToolRow({ view, awaitingInput = false, decisionBearing, inCurren
         heldOpenOf(view, toolView, decisionBearing ?? awaitingInput);
     return (_jsxs(Disclosure, { variant: "bare", open: heldRowOpen || undefined, ...(view.toolCallId !== undefined && view.toolCallId !== ""
             ? { rootDataAttributes: { "data-tf-tool-call-id": view.toolCallId } }
-            : {}), className: "tf:w-full", summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-3 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground", bodyClassName: "tf:flex tf:flex-col tf:gap-2 tf:pt-1 tf:pb-2 tf:ps-7", summary: _jsxs(_Fragment, { children: [toolView.icons.length === 0 ? (_jsx(OperationMark, { icon: presentation.icon, status: presentation.status })) : (
-                // A registered icon (tool-views.md: one registration, two
-                // roles) replaces the mark's glyph and nothing else — the
-                // slot keeps the package chrome and this first-child
-                // position stays the TVC-050 contract.
-                _jsx(ToolViewIconSlot, { icons: toolView.icons, call: toolView.call, icon: presentation.icon })), presentation.status === "input-available" ? (_jsx(ShimmerText, { className: "tf:leading-none", children: presentation.headline })) : (_jsx("span", { className: "tf:leading-none", children: presentation.headline })), presentation.status === "output-error" ? (_jsx(StatePill, { destructive: true, children: "Failed" })) : presentation.status === "denied" ? (
-                // The member's own decision: its own word, plain ink —
-                // never "Interrupted" (the wire's cancel stamp, which this
-                // state outranks) and never the door's "Declined".
-                _jsx(StatePill, { children: "Not approved" })) : presentation.status === "cancelled" ||
-                    presentation.status === "superseded" ? (_jsx(StatePill, { children: "Interrupted" })) : presentation.status === "refused" ? (_jsx(StatePill, { children: "Declined" })) : awaitingInput ? (_jsx(StatePill, { children: "Needs input" })) : null, _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: [_jsx("div", { "data-tf-semantic-view": "", className: "tf:mt-1", children: _jsx(ToolViewSlot, { views: toolView.views, call: toolView.call }) }), view.offloaded === true && (
-            // The offloaded settle: the wire holds the offloader's model-facing
-            // replacement (withheld by the view model); this quiet line is the story.
-            _jsx("p", { className: "tf:text-xs tf:text-tf-muted-foreground", children: "This result was too long to show in full, so the assistant worked from a shortened preview." })), view.refusalText !== undefined && (
-            // The declined reason: the door's own sentence, in the same quiet
-            // register as the offloaded line — never destructive ink.
-            _jsx("p", { "data-tf-refusal-reason": "", className: "tf:text-xs tf:text-tf-muted-foreground", children: view.refusalText })), view.errorText !== undefined && (
-            // The failure's one sentence: the pill already says "Failed", so
-            // the reason reads quietly, with no label and never the wire JSON.
-            _jsx("p", { "data-tf-error-reason": "", className: "tf:text-xs tf:text-tf-muted-foreground", children: humanFailureSentenceOf(view.errorText) }))] }));
+            : {}), className: "tf:w-full", summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-3 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground", bodyClassName: "tf:flex tf:flex-col tf:gap-2 tf:pt-1 tf:pb-2 tf:ps-7", summary: _jsxs(_Fragment, { children: [toolView.icons.length === 0 ? (_jsx(OperationMark, { icon: presentation.icon, status: presentation.status })) : (_jsx(ToolViewIconSlot, { icons: toolView.icons, call: toolView.call, icon: presentation.icon })), presentation.status === "input-available" ? (_jsx(ShimmerText, { className: "tf:leading-none", children: presentation.headline })) : (_jsx("span", { className: "tf:leading-none", children: presentation.headline })), presentation.status === "output-error" ? (_jsx(StatePill, { destructive: true, children: "Failed" })) : presentation.status === "denied" ? (_jsx(StatePill, { children: "Not approved" })) : presentation.status === "cancelled" ||
+                    presentation.status === "superseded" ? (_jsx(StatePill, { children: "Interrupted" })) : presentation.status === "refused" ? (_jsx(StatePill, { children: "Declined" })) : awaitingInput ? (_jsx(StatePill, { children: "Needs input" })) : null, _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: [_jsx("div", { "data-tf-semantic-view": "", className: "tf:mt-1", children: _jsx(ToolViewSlot, { views: toolView.views, call: toolView.call }) }), view.offloaded === true && (_jsx("p", { className: "tf:text-xs tf:text-tf-muted-foreground", children: "This result was too long to show in full, so the assistant worked from a shortened preview." })), view.refusalText !== undefined && (_jsx("p", { "data-tf-refusal-reason": "", className: "tf:text-xs tf:text-tf-muted-foreground", children: view.refusalText })), view.errorText !== undefined && (_jsx("p", { "data-tf-error-reason": "", className: "tf:text-xs tf:text-tf-muted-foreground", children: humanFailureSentenceOf(view.errorText) }))] }));
 }
-//# sourceMappingURL=tool-row.js.map

package/dist/components/tool-view-registry-context.js

@@ -1,19 +1,6 @@
 "use client";
 import { createContext, useContext } from "react";
-// The provider's tool-view registry channel to the transcript surfaces
-// (tool-views.md). A separate context from the session for the same
-// reason appearance is: hosts write the `toolViews` prop as an inline
-// object literal, and a registry holds adapters — the theme prop's
-// serialize-and-key trick cannot apply, so the registry must be
-// structurally unable to reach the session's memo keys, where a
-// fresh-per-render identity would tear down and rebuild the
-// conversation transport.
 export const ToolViewRegistryContext = createContext(null);
-/** The tolerant read: `undefined` outside a provider, which is what
- *  keeps bare mounts (tests, fixtures) and registry-less hosts — React
- *  or script-tag, registering nothing stays fully supported — on
- *  package defaults everywhere. */
 export function useToolViewRegistry() {
     return useContext(ToolViewRegistryContext) ?? undefined;
 }
-//# sourceMappingURL=tool-view-registry-context.js.map

package/dist/components/tool-view-slot.js

@@ -7,101 +7,33 @@ import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
 import { DefaultToolView } from "./tool-arguments-summary.js";
 import { useLatestRef } from "./use-latest-ref.js";
 import { useResolvedThemeMode } from "./use-resolved-theme-mode.js";
-// The tool-view mount slot: the runtime half of the resolution ladder.
-// The presenter resolved the static candidates (rungs 1–3); this slot
-// mounts the first, delivers prop changes through `update` IN PLACE
-// (never a remount — a view's local UI state must survive a status
-// advance), and on a mount/update throw advances to the rung below —
-// monotonic, so a flaky adapter never flickers back in. Exhausting the
-// candidates lands on rung 4, the package default view, the slot's own
-// terminal (the row has no override).
-//
-// Composition law: everything inside the mount container belongs to the
-// adapter; nothing package-owned lives there. The row's error, refusal
-// and offloaded lines (tool-row.tsx) render OUTSIDE this slot, so neither
-// a hostile adapter nor a throw can remove them.
-/** The row-body slot: the mounted candidate's container, or the rung-4
- *  terminal. It adds no heading of its own — a view titles itself (the
- *  package parts carry the card title), so nothing here can claim a
- *  result that a request-shaped view does not show. */
 export function ToolViewSlot({ views, call, }) {
     const slotRef = useRef(null);
     const mountRef = useRef(null);
     const themeMode = useResolvedThemeMode(slotRef);
     const props = { call, context: { themeMode } };
     const active = useMountedAdapter(views, props, mountRef);
-    return (_jsx("div", { ref: slotRef, "data-tf-tool-view": active?.key ?? "", children: active !== undefined ? (
-        // data-tf-host-view marks the HOST's subtree: the sheet's
-        // border/box reset excludes everything under it, so a host
-        // utility on the view's own elements wins — the widget must not
-        // out-cascade its documented extension point. The row body's
-        // compact register rides the mount node, so a host view inherits
-        // the transcript's size and leading by setting nothing of its own
-        // (the inherit-don't-specify law).
-        _jsx("div", { ref: mountRef, "data-tf-host-view": "", className: "tf:text-xs" })) : (_jsx(DefaultToolView, { call: call, context: { themeMode } })) }));
+    return (_jsx("div", { ref: slotRef, "data-tf-tool-view": active?.key ?? "", children: active !== undefined ? (_jsx("div", { ref: mountRef, "data-tf-host-view": "", className: "tf:text-xs" })) : (_jsx(DefaultToolView, { call: call, context: { themeMode } })) }));
 }
-/** The operation-mark slot: a registered icon replaces the mark's GLYPH
- *  and nothing else — the mark's identity, state attribute, ink rules
- *  and assistive state word stay package-owned (OperationMarkFrame),
- *  outside anything an adapter can reach. The terminal is the package
- *  glyph for the resolved icon token. */
 export function ToolViewIconSlot({ icons, call, icon, }) {
     const mountRef = useRef(null);
     const themeMode = useResolvedThemeMode(mountRef);
     const props = { call, context: { themeMode } };
     const active = useMountedAdapter(icons, props, mountRef);
-    return (_jsx(OperationMarkFrame, { status: call.status, children: active !== undefined ? (
-        // aria-hidden like every package glyph (OperationGlyph): the
-        // mark's assistive content is the frame's sr-only state word,
-        // package-owned — an icon adapter mounting text or a titled SVG
-        // must not join the row summary's accessible name beside it.
-        _jsx("span", { ref: mountRef, "aria-hidden": true, "data-tf-host-view": "", "data-tf-tool-view-icon": active.key })) : (_jsx(OperationGlyph, { icon: icon })) }));
+    return (_jsx(OperationMarkFrame, { status: call.status, children: active !== undefined ? (_jsx("span", { ref: mountRef, "aria-hidden": true, "data-tf-host-view": "", "data-tf-tool-view-icon": active.key })) : (_jsx(OperationGlyph, { icon: icon })) }));
 }
-/**
- * The shared adapter lifecycle: mount once, update in place, destroy on
- * unmount, advance on failure. Effects key on the ADAPTER's identity
- * (registrations live at module scope by contract), never on the
- * candidate wrapper the presenter rebuilds per render. Failures are
- * tracked by adapter identity, never by position, and the failed set only
- * grows within a mount. The failure census and the resolution-change
- * census: docs/transcript-surfaces.md, "The tool-view mount slot".
- */
 function useMountedAdapter(candidates, props, nodeRef) {
     const [failedAdapters, setFailedAdapters] = useState(EMPTY_FAILED);
     const active = candidates.find((candidate) => !failedAdapters.has(candidate.adapter));
     const adapter = active?.adapter;
-    // Tolerant on purpose: fixture and bare test mounts have no session;
-    // failures then reach only the console, while a real embed's land on
-    // the host's onError — observable to developers, no stack traces
-    // shown to end users.
     const session = useOptionalAssistantSession();
     const reportErrorRef = useLatestRef(session?.reportError);
-    // The key NAMES the failing view in reports; it must never be an
-    // ADVANCE signal. One adapter registered under two keys (the README's
-    // own double-registration shape) re-resolves from rung 2 to rung 1
-    // when the wire ref lands late — same adapter, new key — and a key
-    // dependency on useAdapterMount would destroy and remount the view,
-    // discarding exactly the local UI state that update-in-place exists
-    // to preserve. It rides the mount record instead, written at commit
-    // time, so reports name the currently-resolved key.
     const heldRef = useRef({
         instance: null,
         deliveredProps: null,
         props,
         key: active?.key,
     });
-    // ONE report-clear-advance path for every failure phase in the
-    // FAILURE CENSUS: report to the host, clear the failed adapter's
-    // debris, drop the mounted instance, and skip the adapter everywhere
-    // it resolves. The WeakSet dedupes per adapter object — a late event
-    // and a straggling stale throw must not double-report. What keeps a
-    // failed adapter from being reached twice is the INSTANCE DROP here:
-    // two commits can queue two deliveries while the instance is still
-    // live (flushSync ×2 before any drain), and the first delivery's
-    // catch nulls the instance, so the second returns at its null check.
-    // The failure state applying before any later commit — whose cleanup
-    // also nulls the mount — is the belt on top, not the load-bearing
-    // guard.
     const reportedFailuresRef = useRef(new WeakSet());
     const advancePast = useCallback((failedAdapter, error) => {
         if (reportedFailuresRef.current.has(failedAdapter)) {
@@ -126,27 +58,15 @@ function useMountedAdapter(candidates, props, nodeRef) {
     return active;
 }
 const EMPTY_FAILED = new Set();
-/** Mount and destroy, one adapter at a time. Every adapter call is
- *  deferred ONE microtask past the React commit: the React sugar's
- *  mount/update is a flushSync render into a nested root and its destroy
- *  is a root unmount, and React forbids both while its own commit is
- *  still on the stack (an effect or a cleanup). The microtask runs
- *  before the member can interact, and the relative order — destroy
- *  before the next mount — rides the queue's FIFO. */
 function useAdapterMount(adapter, nodeRef, heldRef, advancePast) {
     useEffect(() => {
         const node = nodeRef.current;
-        // The record object is the slot's for its whole lifetime (only its
-        // fields change), so the cleanup reads it directly.
         const held = heldRef.current;
         if (adapter === undefined || node === null) {
             return;
         }
         let cancelled = false;
         let instance = null;
-        // The React sugar's self-scheduled-render failure channel (failure
-        // census case 5): dispatched on the mount container, the one object
-        // the sugar and this slot share.
         const onLateFailure = (event) => {
             advancePast(adapter, event.detail);
         };
@@ -169,12 +89,6 @@ function useAdapterMount(adapter, nodeRef, heldRef, advancePast) {
             node.removeEventListener(TOOL_VIEW_LATE_FAILURE_EVENT, onLateFailure);
             held.instance = null;
             held.deliveredProps = null;
-            // Captured NOW, not at destroy time: cleanups run before the next
-            // commit's create-phase effects, but the deferred destroy below
-            // runs after them — by then the record already names the NEXT
-            // resolution (or "" at the terminal), and the log would blame the
-            // wrong view. This cleanup still tracks a re-key: the record holds
-            // whatever key this adapter was last resolved under.
             const destroyedKey = held.key ?? "";
             queueMicrotask(() => {
                 if (instance === null) {
@@ -189,23 +103,8 @@ function useAdapterMount(adapter, nodeRef, heldRef, advancePast) {
                 node.replaceChildren();
             });
         };
-        // Neither the cursor nor the KEY is in the deps, ON PURPOSE: the
-        // adapter's identity is the ONLY advance signal. An advance always changes `adapter` by
-        // construction (a failed adapter is skipped at every position it
-        // occupies), and a key change with an unchanged adapter — the late
-        // wire ref re-resolving one double-registered adapter from rung 2
-        // to rung 1 — is a re-labelling, not a reason to destroy a mounted
-        // view.
     }, [adapter, advancePast, heldRef, nodeRef]);
 }
-/** Every commit after the mount delivers the LATEST committed props
- *  through `update` — in place, never a remount. The delivery guard is
- *  STRUCTURAL: the presenter mints a fresh call per invocation and this
- *  slot a fresh props object per render, so an object-identity guard is
- *  dead by construction — it would suppress only the mount's own
- *  duplicate and hand every mounted view an update per streamed token
- *  (with the React sugar, a synchronous render into a nested root per
- *  token, on calls that already settled). */
 function useAdapterDelivery(adapter, key, props, heldRef, advancePast) {
     useEffect(() => {
         const held = heldRef.current;
@@ -234,15 +133,6 @@ function useAdapterDelivery(adapter, key, props, heldRef, advancePast) {
         });
     });
 }
-/**
- * "Nothing a view can observe changed." The field set rests on three
- * premises — `result`/`truncated` derive from `resultText` (lazy
- * accessors over it, so the guard compares the source text and never
- * forces the structuring parse); `args` is identity-stable across
- * re-renders with unchanged source (the IDENTITY LAW); the schema refs
- * are identity-stable per source — each stated in
- * docs/transcript-surfaces.md, "The delivery guard's premises".
- */
 function _sameDelivery(previous, next) {
     const before = previous.call;
     const after = next.call;
@@ -276,9 +166,6 @@ function _shallowRecordEqual(before, after) {
     return true;
 }
 function _reportThrow(key, error, reportError) {
-    // The host's observer hears it, and the console names the view for
-    // whoever is actually debugging the page.
     reportError?.(error instanceof Error ? error : new Error(String(error)));
     console.error(`[teaflask-assistant] The tool view "${key}" threw; the next resolution took over.`, error);
 }
-//# sourceMappingURL=tool-view-slot.js.map

package/dist/components/tool-views/action-view.js

@@ -1,22 +1,3 @@
-// teaflask.action — the package's one view for every `action__{slug}`
-// tool (tool-views.md, rung 3): customer HTTP actions are structurally
-// our tools — generated from the catalog, their arguments always the
-// same three-key envelope {path_params, query, body} — so one shipped
-// view renders any org's action, in every host, with zero customer
-// frontend work. It reads the recorded call and nothing else: the
-// method and path template ride only the execution-request marker, not
-// the call's bounded props, so they are deliberately not shown — a
-// built-in gets no privileged data. Producer transforms and argument
-// ledger: docs/tool-view-ledgers.md. Arm reachability and the two
-// truncation channels: the tool-view arm-reachability record.
-//   settledOutcomeNotesOf arms — REACHABLE: tool-row no longer gates
-//     output, so a refused, errored (output-error), denied, cancelled,
-//     superseded or offloaded rung-3 call renders its arm in production;
-//     a still-RUNNING call renders none (input-streaming/input-available
-//     break out to []).
-//   resultText === undefined early return — unreachable today (its call
-//     site is guarded by settledWithResult); kept as totality: a view
-//     never throws on posed props.
 import { prettyPrintParameters } from "../pretty-print.js";
 import { CARD_BLOCK_CLASS } from "./parts-classes.js";
 import { actionEnvelopeOf, actionFailureOf, captionRow, card, el, factRows, note, recordOf, scrollRegion, settledOutcomeNotesOf, settledWithResult, statelessToolView, } from "./view-dom.js";
@@ -25,7 +6,7 @@ const REQUEST_SECTIONS = [
     ["query", "Query"],
     ["body", "Body"],
 ];
-const VALUE_PANE_CLASS = "tf:m-0 tf:whitespace-pre-wrap tf:font-mono tf:text-xs tf:text-tf-foreground";
+const VALUE_PANE_CLASS = "tf:m-0 tf:whitespace-pre-wrap tf:font-mono tf:text-xs tf:text-tf-card-foreground";
 export const actionToolView = statelessToolView(_renderAction);
 function _renderAction({ call }) {
     const root = el("div", "tf:flex tf:flex-col tf:gap-2");
@@ -36,10 +17,6 @@ function _renderAction({ call }) {
         if (value === undefined || value === null) {
             continue;
         }
-        // An empty record is the same absence the argument ledger already
-        // describes — a labeled section holding "{}" would be a content-free
-        // frame. An empty ARRAY body still renders: "[]" is a value the
-        // customer's endpoint received.
         const record = recordOf(value);
         if (record !== null && Object.keys(record).length === 0) {
             continue;
@@ -58,10 +35,6 @@ function _renderAction({ call }) {
     }
     return root;
 }
-/** A failure's per-field problems as property rows, the one structured
- *  fact a failed action carries: the row beside this view already says
- *  Failed and the human reason, so the view adds the fields alone —
- *  never the status or error code. Nothing when the API named none. */
 function _appendFieldProblems(root, call) {
     const detail = actionFailureOf(call.errorText)?.detail;
     const fields = detail?.fields ?? [];
@@ -73,20 +46,12 @@ function _appendFieldProblems(root, call) {
     const parts = [captionRow("Field problems"), rows];
     const omitted = detail?.fieldsOmitted ?? 0;
     if (omitted > 0) {
-        // The API named more than the record carries: say so, never let a
-        // partial list read as the whole.
         const more = captionRow(`${String(omitted)} more ${omitted === 1 ? "problem" : "problems"} not listed here.`);
         more.dataset.tfActionFieldProblemsOmitted = String(omitted);
         parts.push(more);
     }
     root.append(card(parts));
 }
-/** A record becomes property rows (one per top-level key, nested values
- *  pretty-printed); anything else — an array, a scalar — is one
- *  pretty-printed block on the same card-child grammar as the rows: the
- *  hairline above, the rows' inset. Either rides in a bounded scrolling
- *  well: a body can run to the door's 20k, and a value that tall would
- *  be the transcript's height, not a card's. */
 function _valueRows(value) {
     const record = recordOf(value);
     if (record !== null) {
@@ -119,10 +84,6 @@ function _appendResponse(root, call) {
     }
     const envelope = actionEnvelopeOf(call.resultText);
     if (envelope === null) {
-        // Covers the wire's 20k clip too: `call.truncated` is set only by a
-        // WELL-FORMED envelope whose result.truncated is true — which by
-        // construction parsed — so "unparseable but flagged truncated"
-        // cannot co-occur and earns no arm of its own.
         root.append(note("The response couldn't be read as an action result and isn't rendered."));
         return;
     }
@@ -148,4 +109,3 @@ function _appendResponse(root, call) {
     }
     root.append(card(rows));
 }
-//# sourceMappingURL=action-view.js.map

package/dist/components/tool-views/command-view.js

@@ -1,23 +1,4 @@
-// teaflask.command — a command and its output (tool-views.md, rung 3) as
-// one terminal block: `$ command`, then what it printed. Authored for
-// sandbox_bash and docs_filesystem, which share the shape (a `command`
-// string), and total over their two recorded result formats — the
-// {output, error} record and plain text — by SHAPE, never by tool name:
-// the package presents its own tools only through the opaque-key seam.
-// Argument ledger and producer transforms: docs/tool-view-ledgers.md. Arm
-// reachability and the two truncation channels (1: the envelope's
-// result.truncated → call.truncated; 2: the mapper's 20k clip, invisible
-// client-side and the COMMON one here): the tool-view arm-reachability
-// record.
-//   settledOutcomeNotesOf arms — REACHABLE: tool-row no longer gates
-//     output, so a refused, errored (output-error), denied, cancelled,
-//     superseded or offloaded rung-3 call renders its arm in production;
-//     a still-RUNNING call renders none.
-//   call.truncated arm — channel 1 only: when the unwrapper says the
-//     recorded copy is degraded, the view must refuse to structure it.
 import { el, note, recordOf, settledOutcomeNotesOf, settledWithResult, statelessToolView, stringOf, terminal, } from "./view-dom.js";
-/** docsfs's model-facing replacement for a silent exit-0 run
- *  (_render_run_result) — not stdout, so never rendered as output. */
 const DOCS_NO_OUTPUT_SENTENCE = "The command ran with exit code 0 and produced no output.";
 const INCOMPLETE = "The recorded output is incomplete and isn't rendered.";
 const NO_OUTPUT = "The command produced no output.";
@@ -27,8 +8,6 @@ function _renderCommand({ call }) {
     root.dataset.tfCommandView = "";
     const command = stringOf(call.args.command);
     const streams = settledWithResult(call) ? _streamsOf(call) : null;
-    // The block exists for a prompt line or a stream — an empty or absent
-    // command with nothing printed would paint an empty bordered pre.
     const hasCommand = command !== null && command !== "";
     if (hasCommand || streams?.kind === "streams") {
         root.append(terminal({
@@ -47,8 +26,6 @@ function _streamsOf(call) {
     if (call.truncated === true) {
         return { kind: "note", text: INCOMPLETE };
     }
-    // The sandbox_bash shape: {"output": stdout, "error": stderr} — both
-    // strings by construction.
     const result = recordOf(call.result);
     const output = result === null ? null : stringOf(result.output);
     const stderr = result === null ? null : stringOf(result.error);
@@ -57,13 +34,9 @@ function _streamsOf(call) {
             ? { kind: "note", text: NO_OUTPUT }
             : { kind: "streams", output, stderr };
     }
-    // The mapper's 20k clip (channel 2) cuts the bash record mid-JSON:
-    // parse fails and resultText holds the cut document, not the output.
     if (call.result === undefined && call.resultText?.startsWith("{") === true) {
         return { kind: "note", text: INCOMPLETE };
     }
-    // The docs_filesystem shape: one text block (stdout, plus [stderr] /
-    // [exit code N] markers only when they occurred).
     if (call.resultText === undefined) {
         return null;
     }
@@ -71,4 +44,3 @@ function _streamsOf(call) {
         ? { kind: "note", text: NO_OUTPUT }
         : { kind: "streams", output: call.resultText, stderr: "" };
 }
-//# sourceMappingURL=command-view.js.map