@teaflask/assistant 0.3.0 → 0.6.0

package/dist/components/tool-views/file-edit-view.js

@@ -1,22 +1,3 @@
-// teaflask.file-edit — the recorded edit as a diff (tool-views.md,
-// rung 3). The diff derives from the ARGS — str_replace carries the
-// full old/new pair, insert its added lines, create the whole file —
-// because the result carries only a post-edit snippet. On a settled
-// call the editor applied exactly this change (unique-occurrence
-// enforced backend-side); before it settles the same shape is labeled
-// a proposal, so the view never claims an edit that hasn't happened.
-// Producer transforms, argument ledger and the boundary-newline
-// cross-product: docs/tool-view-ledgers.md. Arm reachability and the
-// two truncation channels (the diff arms derive from the ARGS and are
-// immune to both): the tool-view arm-reachability record.
-//   settledOutcomeNotesOf arms — REACHABLE: tool-row no longer gates
-//     output, so the refused/output-error/denied/cancelled/superseded/
-//     offloaded settles render their arms in production (a
-//     still-running call renders none — the switch breaks out); see
-//     view-dom.ts.
-//   elision marking (_diffPane) — every recorded line the Myers pane
-//     does not render is marked with a ⋯: leading, between hunks, and
-//     trailing. A pane without ⋯ IS the whole recorded fragment.
 import { unifiedDiffOf } from "../../reader/line-diff.js";
 import { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS, el, note, pane, settledOutcomeNotesOf, settledWithResult, statelessToolView, stringOf, } from "./view-dom.js";
 export const fileEditToolView = statelessToolView(_renderFileEdit);
@@ -53,17 +34,11 @@ function _renderFileEdit({ call }) {
 }
 function _strReplaceReadingOf(call, settled) {
     const oldStr = stringOf(call.args.old_str);
-    // new_str is optional for str_replace and omitting it DELETES the
-    // match (the editor expands a missing or empty new_str to "") — so an
-    // absent value is a deletion to render, and only a wrong-typed one is
-    // unrenderable.
     const rawNewStr = call.args.new_str;
     const newStr = rawNewStr === undefined || rawNewStr === null ? "" : stringOf(rawNewStr);
     if (oldStr === null || newStr === null) {
         return note("No rendered edit for this call.");
     }
-    // The editor matches and writes tab-EXPANDED fragments, so the file
-    // received these bytes, and equality is judged on them.
     const expandedOld = _expandedTabs(oldStr);
     const expandedNew = _expandedTabs(newStr);
     if (newStr === "" && oldStr !== "") {
@@ -81,12 +56,8 @@ function _createReadingOf(call, settled) {
         return note("No rendered edit for this call.");
     }
     if (fileText === "") {
-        // An empty file has no added lines; a bare "+" would claim one.
         return note(settled ? "Created an empty file." : "Proposes an empty file.");
     }
-    // Verbatim on purpose: create is the one command the editor does NOT
-    // tab-expand, and a leading newline really is a blank first line —
-    // only the trailing terminator drops.
     return _diffPane(settled ? "New file" : "Proposed new file", _prefixedLines(_withoutTrailingNewline(fileText), "+"));
 }
 function _insertReadingOf(call, settled) {
@@ -95,22 +66,11 @@ function _insertReadingOf(call, settled) {
         return note("No rendered edit for this call.");
     }
     const line = call.args.insert_line;
-    // insert_line counts the existing lines that PRECEDE the insertion —
-    // the editor splices at file_text_lines[:insert_line] and accepts
-    // only integers in [0, n_lines] — so 0 is the top of the file, a
-    // positive integer reads as the ordinary "after line N" (1-indexed
-    // reading), and anything the editor would refuse (negative,
-    // fractional, non-number) claims no position at all. The vended
-    // docstring says "0-indexed"; its own splice contradicts it, and the
-    // splice is what runs.
     const where = typeof line !== "number" || !Number.isInteger(line) || line < 0
         ? ""
         : line === 0
             ? " at the top of the file"
             : ` after line ${String(line)}`;
-    // Tab-expanded (the splice inserts expanded lines), but no boundary
-    // drops: split("\n") is spliced verbatim, so leading and trailing
-    // newlines really insert blank lines.
     return _diffPane(settled ? `Inserted${where}` : `Proposed insertion${where}`, _prefixedLines(_expandedTabs(newStr), "+"));
 }
 function _viewedContentsReadingOf(call, settled) {
@@ -120,29 +80,17 @@ function _viewedContentsReadingOf(call, settled) {
     if (call.resultText === undefined || call.resultText === "") {
         return note("Nothing to show for this read.");
     }
-    // "Contents", not "File": a view over a directory returns a listing,
-    // and the recorded args cannot tell the two apart.
     return pane("Contents", _withoutViewPreamble(call.resultText));
 }
-/** The editor's own transform: "\t" → 8 spaces, applied to old_str and
- *  new_str (never file_text) before matching and writing. */
 function _expandedTabs(text) {
     return text.replaceAll("\t", "        ");
 }
-/** One trailing "\n" is a terminator, not a line. */
 function _withoutTrailingNewline(text) {
     return text.endsWith("\n") ? text.slice(0, -1) : text;
 }
-/** Deletion drops one newline at EACH boundary: the leading one is the
- *  preceding line's terminator consumed as the joint, the trailing one
- *  the last deleted line's own (the cross-product above). */
 function _withoutBoundaryNewlines(text) {
     return _withoutTrailingNewline(text.startsWith("\n") ? text.slice(1) : text);
 }
-/** A view result is never bare contents: the vended tool opens with one
- *  deterministic model-facing sentence (file or directory form, both
- *  ending in ":"), restating the path the header line above already
- *  shows — dropped so the pane holds the recorded read alone. */
 function _withoutViewPreamble(text) {
     const newline = text.indexOf("\n");
     if (newline === -1) {
@@ -160,17 +108,6 @@ function _prefixedLines(text, prefix) {
         .map((line) => `${prefix}${line}`)
         .join("\n");
 }
-/** The diff register: additions in foreground ink, deletions in the
- *  status voice, context muted (no success token exists in Graphite —
- *  none is minted). Hunk headers render as quiet ⋯ separators: their
- *  offsets are relative to the recorded fragment, and printing numbers
- *  that read as file lines would be a wrong claim — but every ELISION
- *  is marked: a first hunk opening past the
- *  fragment's first line gets a leading ⋯, and when `oldLineCount` is
- *  given (the Myers arm), recorded lines past the last hunk get a
- *  trailing ⋯ — the pane never reads as a complete diff of a fragment
- *  it elided. Lines join with prepended newlines so the pane carries no
- *  trailing empty line box. */
 function _diffPane(label, diff, oldLineCount) {
     const wrapper = el("div", PANE_WRAPPER_CLASS);
     wrapper.append(el("p", LABEL_CLASS, label));
@@ -181,9 +118,6 @@ function _diffPane(label, diff, oldLineCount) {
         code.append(el("span", className, rendered === 0 ? text : `\n${text}`));
         rendered += 1;
     };
-    // The first recorded-fragment line AFTER the last hunk (1-indexed),
-    // from the header's own `-start,count` — the only place the diff
-    // says how far it reached.
     let afterLastHunk = null;
     for (const line of diff.split("\n")) {
         if (line.startsWith("@@")) {
@@ -191,9 +125,6 @@ function _diffPane(label, diff, oldLineCount) {
             if (header !== null) {
                 afterLastHunk = Number(header[1]) + Number(header[2]);
             }
-            // A hunk opening at the fragment's first line elides nothing
-            // before it; every other header stands for skipped recorded
-            // lines and must say so.
             if (rendered > 0 || !line.startsWith("@@ -1,")) {
                 append("tf:text-tf-muted-foreground", "⋯");
             }
@@ -215,4 +146,3 @@ function _diffPane(label, diff, oldLineCount) {
     wrapper.append(pre);
     return wrapper;
 }
-//# sourceMappingURL=file-edit-view.js.map

package/dist/components/tool-views/parts-classes.d.ts

@@ -8,40 +8,21 @@ export declare const ROW_TITLE_CLASS = "tf:truncate tf:text-tf-label tf:font-med
 export declare const ROW_SECONDARY_CLASS = "tf:truncate tf:text-xs tf:text-tf-muted-foreground";
 export declare const ROW_TRAIL_CLASS = "tf:ms-auto tf:flex tf:shrink-0 tf:items-center tf:gap-2";
 export declare const BADGE_CLASS = "tf:inline-flex tf:shrink-0 tf:items-center tf:rounded-[3px] tf:border tf:border-tf-border tf:px-1.5 tf:py-px tf:text-[11px] tf:leading-4 tf:font-medium tf:text-tf-foreground";
-/** The property-row list: a hairline above it when it follows a caption
- *  or a row, none when it opens the card — the rows' own first-child rule,
- *  applied to their container. */
 export declare const FACT_LIST_CLASS = "tf:m-0 tf:border-t tf:border-tf-border tf:first:border-t-0";
 export declare const FACT_ROW_CLASS = "tf:grid tf:grid-cols-[minmax(6rem,30%)_minmax(0,1fr)] tf:gap-x-3 tf:border-t tf:border-tf-border tf:px-2.5 tf:py-1.5 tf:first:border-t-0";
 export declare const FACT_LABEL_CLASS = "tf:min-w-0 tf:text-xs tf:text-tf-muted-foreground tf:wrap-anywhere";
 export declare const FACT_VALUE_CLASS = "tf:m-0 tf:min-w-0 tf:text-xs tf:text-tf-foreground tf:wrap-anywhere";
 export declare const CAPTION_ROW_CLASS = "tf:flex tf:items-center tf:justify-between tf:gap-3 tf:border-t tf:border-tf-border tf:px-2.5 tf:py-1.5 tf:text-xs tf:text-tf-muted-foreground tf:first:border-t-0";
-/** A block child of a card that is not a row — a pretty-printed value,
- *  an inset pane, a body: the same hairline above (none when it opens
- *  the card) and the same inset the rows keep. */
 export declare const CARD_BLOCK_CLASS = "tf:border-t tf:border-tf-border tf:px-2.5 tf:py-2 tf:first:border-t-0";
 export declare const BODY_REGION_CLASS = "tf:max-h-72 tf:overflow-auto tf:border-t tf:border-tf-border tf:px-2.5 tf:py-2 tf:first:border-t-0";
 export declare const NOTE_CLASS = "tf:text-xs tf:text-tf-muted-foreground";
-/** Skeleton lines where the result will land: the first a half-width
- *  title, the rest full-width text — pending is a shape, not a sentence,
- *  and it draws no edges: no card, no border, the lines alone. */
 export declare const BONES_CLASS = "tf:flex tf:flex-col tf:gap-2 tf:py-1";
 export declare const BONE_CLASS = "tf:h-2.5 tf:animate-tf-pulse tf:rounded tf:bg-tf-muted";
-/** A label over a pane: the one label-to-pane rhythm (the pane carries
- *  no margin of its own, so a host's reset cannot collapse the gap). */
 export declare const PANE_WRAPPER_CLASS = "tf:flex tf:flex-col tf:gap-1";
-/** The mono pane for text that IS text (a command's output, a diff): on
- *  the muted ground inside a card, never a second border. */
 export declare const PANE_CLASS = "tf:m-0 tf:max-h-60 tf:overflow-auto tf:rounded-md tf:bg-tf-muted tf:p-2 tf:text-xs tf:whitespace-pre-wrap tf:text-tf-foreground";
-/** A command and what it printed, as one terminal block: the prompt line
- *  in the foreground, the streams beneath it in the muted register. */
 export declare const TERMINAL_CLASS = "tf:m-0 tf:max-h-72 tf:overflow-auto tf:rounded-lg tf:border tf:border-tf-border tf:bg-tf-muted tf:px-3 tf:py-2.5 tf:font-mono tf:text-xs tf:leading-5 tf:whitespace-pre-wrap tf:wrap-anywhere tf:text-tf-foreground";
 export declare const TERMINAL_PROMPT_CLASS = "tf:select-none tf:text-tf-muted-foreground";
 export declare const TERMINAL_OUTPUT_CLASS = "tf:mt-1 tf:block tf:text-tf-muted-foreground";
 export declare const TERMINAL_STDERR_CLASS = "tf:mt-1 tf:block tf:text-tf-muted-foreground tf:italic";
-/** A long list or value inside a card scrolls in a bounded well instead
- *  of growing the transcript — a card child itself (hairline above unless
- *  first; its first child's own hairline yields), so one line per edge. */
 export declare const SCROLL_REGION_CLASS = "tf:max-h-72 tf:overflow-auto tf:border-t tf:border-tf-border tf:first:border-t-0";
 export declare const LABEL_CLASS = "tf:text-xs tf:font-medium tf:text-tf-muted-foreground";
-//# sourceMappingURL=parts-classes.d.ts.map

package/dist/components/tool-views/parts-classes.js

@@ -1,10 +1,3 @@
-// The one visual vocabulary every tool view speaks — the package's own
-// built-ins (vanilla, view-dom.ts) and host views (React, parts.tsx) share
-// these strings, so a customer's view and ours read as one system: a
-// hairline card at rest, dense list rows with a title line and a muted
-// second line, a trailing badge, property rows, a quiet caption, a
-// scrolling body region. Graphite: 13px labels, hairline borders, no
-// shadow, and a compact vertical rhythm — 6px row padding, 24px tiles.
 export const CARD_CLASS = "tf:overflow-hidden tf:rounded-lg tf:border tf:border-tf-border tf:bg-tf-card";
 export const CARD_TITLE_CLASS = "tf:mb-1 tf:text-tf-label tf:font-medium tf:text-tf-foreground";
 export const ROW_CLASS = "tf:flex tf:min-w-0 tf:items-center tf:gap-2.5 tf:border-t tf:border-tf-border tf:px-2.5 tf:py-1.5 tf:first:border-t-0";
@@ -15,40 +8,21 @@ export const ROW_TITLE_CLASS = "tf:truncate tf:text-tf-label tf:font-medium tf:t
 export const ROW_SECONDARY_CLASS = "tf:truncate tf:text-xs tf:text-tf-muted-foreground";
 export const ROW_TRAIL_CLASS = "tf:ms-auto tf:flex tf:shrink-0 tf:items-center tf:gap-2";
 export const BADGE_CLASS = "tf:inline-flex tf:shrink-0 tf:items-center tf:rounded-[3px] tf:border tf:border-tf-border tf:px-1.5 tf:py-px tf:text-[11px] tf:leading-4 tf:font-medium tf:text-tf-foreground";
-/** The property-row list: a hairline above it when it follows a caption
- *  or a row, none when it opens the card — the rows' own first-child rule,
- *  applied to their container. */
 export const FACT_LIST_CLASS = "tf:m-0 tf:border-t tf:border-tf-border tf:first:border-t-0";
 export const FACT_ROW_CLASS = "tf:grid tf:grid-cols-[minmax(6rem,30%)_minmax(0,1fr)] tf:gap-x-3 tf:border-t tf:border-tf-border tf:px-2.5 tf:py-1.5 tf:first:border-t-0";
 export const FACT_LABEL_CLASS = "tf:min-w-0 tf:text-xs tf:text-tf-muted-foreground tf:wrap-anywhere";
 export const FACT_VALUE_CLASS = "tf:m-0 tf:min-w-0 tf:text-xs tf:text-tf-foreground tf:wrap-anywhere";
 export const CAPTION_ROW_CLASS = "tf:flex tf:items-center tf:justify-between tf:gap-3 tf:border-t tf:border-tf-border tf:px-2.5 tf:py-1.5 tf:text-xs tf:text-tf-muted-foreground tf:first:border-t-0";
-/** A block child of a card that is not a row — a pretty-printed value,
- *  an inset pane, a body: the same hairline above (none when it opens
- *  the card) and the same inset the rows keep. */
 export const CARD_BLOCK_CLASS = "tf:border-t tf:border-tf-border tf:px-2.5 tf:py-2 tf:first:border-t-0";
 export const BODY_REGION_CLASS = `tf:max-h-72 tf:overflow-auto ${CARD_BLOCK_CLASS}`;
 export const NOTE_CLASS = "tf:text-xs tf:text-tf-muted-foreground";
-/** Skeleton lines where the result will land: the first a half-width
- *  title, the rest full-width text — pending is a shape, not a sentence,
- *  and it draws no edges: no card, no border, the lines alone. */
 export const BONES_CLASS = "tf:flex tf:flex-col tf:gap-2 tf:py-1";
 export const BONE_CLASS = "tf:h-2.5 tf:animate-tf-pulse tf:rounded tf:bg-tf-muted";
-/** A label over a pane: the one label-to-pane rhythm (the pane carries
- *  no margin of its own, so a host's reset cannot collapse the gap). */
 export const PANE_WRAPPER_CLASS = "tf:flex tf:flex-col tf:gap-1";
-/** The mono pane for text that IS text (a command's output, a diff): on
- *  the muted ground inside a card, never a second border. */
 export const PANE_CLASS = "tf:m-0 tf:max-h-60 tf:overflow-auto tf:rounded-md tf:bg-tf-muted tf:p-2 tf:text-xs tf:whitespace-pre-wrap tf:text-tf-foreground";
-/** A command and what it printed, as one terminal block: the prompt line
- *  in the foreground, the streams beneath it in the muted register. */
 export const TERMINAL_CLASS = "tf:m-0 tf:max-h-72 tf:overflow-auto tf:rounded-lg tf:border tf:border-tf-border tf:bg-tf-muted tf:px-3 tf:py-2.5 tf:font-mono tf:text-xs tf:leading-5 tf:whitespace-pre-wrap tf:wrap-anywhere tf:text-tf-foreground";
 export const TERMINAL_PROMPT_CLASS = "tf:select-none tf:text-tf-muted-foreground";
 export const TERMINAL_OUTPUT_CLASS = "tf:mt-1 tf:block tf:text-tf-muted-foreground";
 export const TERMINAL_STDERR_CLASS = "tf:mt-1 tf:block tf:text-tf-muted-foreground tf:italic";
-/** A long list or value inside a card scrolls in a bounded well instead
- *  of growing the transcript — a card child itself (hairline above unless
- *  first; its first child's own hairline yields), so one line per edge. */
 export const SCROLL_REGION_CLASS = "tf:max-h-72 tf:overflow-auto tf:border-t tf:border-tf-border tf:first:border-t-0";
 export const LABEL_CLASS = "tf:text-xs tf:font-medium tf:text-tf-muted-foreground";
-//# sourceMappingURL=parts-classes.js.map

package/dist/components/tool-views/parts.d.ts

@@ -1,5 +1,4 @@
 import type { ReactNode } from "react";
-/** The small label over a card — or over a skeleton, which draws no card. */
 export declare function ToolViewTitle({ children }: {
     children: ReactNode;
 }): import("react").JSX.Element;
@@ -12,8 +11,6 @@ export declare function ToolViewRow({ icon, title, secondary, trailing, href, ..
     title: ReactNode;
     secondary?: ReactNode;
     trailing?: ReactNode;
-    /** A plain anchor: a view lives in its own React root, outside any
-     *  host router, so a row that navigates is a full navigation. */
     href?: string;
 } & Record<`data-${string}`, string | number | undefined>): import("react").JSX.Element;
 export declare function ToolViewFacts({ facts, ...rest }: {
@@ -30,20 +27,15 @@ export declare function ToolViewBody({ label, children, ...rest }: {
     label: string;
     children: ReactNode;
 } & Record<`data-${string}`, string | number | undefined>): import("react").JSX.Element;
-/** A bounded, scrolling region for a long list inside a card. */
 export declare function ToolViewScroll({ children, ...rest }: {
     children: ReactNode;
 } & Record<`data-${string}`, string | number | undefined>): import("react").JSX.Element;
 export declare function ToolViewBadge({ children, ...rest }: {
     children: ReactNode;
 } & Record<`data-${string}`, string | number | undefined>): import("react").JSX.Element;
-/** One quiet sentence in the muted register — for what is absent,
- *  degraded, or not renderable, never for invented structure. */
 export declare function ToolViewNote({ children, ...rest }: {
     children: ReactNode;
 } & Record<`data-${string}`, string | number | undefined>): import("react").JSX.Element;
-/** Skeleton lines where the result will land — pending is a shape. */
 export declare function ToolViewBones({ lines, ...rest }: {
     lines?: number;
 } & Record<`data-${string}`, string | number | undefined>): import("react").JSX.Element;
-//# sourceMappingURL=parts.d.ts.map

package/dist/components/tool-views/parts.js

@@ -1,7 +1,6 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { BADGE_CLASS, BODY_REGION_CLASS, BONES_CLASS, BONE_CLASS, CAPTION_ROW_CLASS, CARD_CLASS, CARD_TITLE_CLASS, FACT_LABEL_CLASS, FACT_LIST_CLASS, FACT_ROW_CLASS, FACT_VALUE_CLASS, NOTE_CLASS, ROW_CLASS, ROW_ICON_CLASS, ROW_LINK_CLASS, ROW_SECONDARY_CLASS, ROW_TEXT_CLASS, ROW_TITLE_CLASS, ROW_TRAIL_CLASS, SCROLL_REGION_CLASS, } from "./parts-classes.js";
-/** The small label over a card — or over a skeleton, which draws no card. */
 export function ToolViewTitle({ children }) {
     return _jsx("p", { className: CARD_TITLE_CLASS, children: children });
 }
@@ -21,20 +20,15 @@ export function ToolViewCaption({ children, trailing, ...rest }) {
 export function ToolViewBody({ label, children, ...rest }) {
     return (_jsx("section", { "aria-label": label, className: BODY_REGION_CLASS, ...rest, children: children }));
 }
-/** A bounded, scrolling region for a long list inside a card. */
 export function ToolViewScroll({ children, ...rest }) {
     return (_jsx("div", { className: SCROLL_REGION_CLASS, "data-tf-scroll-region": "", ...rest, children: children }));
 }
 export function ToolViewBadge({ children, ...rest }) {
     return (_jsx("span", { className: BADGE_CLASS, ...rest, children: children }));
 }
-/** One quiet sentence in the muted register — for what is absent,
- *  degraded, or not renderable, never for invented structure. */
 export function ToolViewNote({ children, ...rest }) {
     return (_jsx("p", { className: NOTE_CLASS, ...rest, children: children }));
 }
-/** Skeleton lines where the result will land — pending is a shape. */
 export function ToolViewBones({ lines = 3, ...rest }) {
     return (_jsx("div", { className: BONES_CLASS, "aria-hidden": true, ...rest, children: Array.from({ length: lines }, (_, index) => (_jsx("span", { className: `${BONE_CLASS} ${index === 0 ? "tf:w-1/2" : "tf:w-full"}` }, index))) }));
 }
-//# sourceMappingURL=parts.js.map

package/dist/components/tool-views/questions-view.d.ts

@@ -1,2 +1 @@
 export declare const questionsToolView: import("../../headless.js").ToolViewAdapter<Record<string, unknown>, unknown>;
-//# sourceMappingURL=questions-view.d.ts.map

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

@@ -8,8 +8,6 @@ function renderQuestions({ call }) {
     const receipt = settledWithResult(call) && call.truncated !== true
         ? settledQuestionsReceiptOf(call.toolName, JSON.stringify(call.args), call.resultText)
         : null;
-    // The active QuestionPanel owns unanswered questions. Keep this view
-    // empty until there is a durable answer record to inspect.
     if (receipt === null) {
         if (settledWithResult(call)) {
             root.append(note("No answers are available in this record."));
@@ -41,4 +39,3 @@ function questionSection(question, answer) {
     }
     return section;
 }
-//# sourceMappingURL=questions-view.js.map

package/dist/components/tool-views/view-dom.d.ts

@@ -2,24 +2,14 @@ import type { ToolViewAdapter, ToolViewCall, ToolViewProps } from "../../core/to
 import { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS } from "./parts-classes.js";
 export { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS };
 export declare function el<K extends keyof HTMLElementTagNameMap>(tag: K, className: string, text?: string): HTMLElementTagNameMap[K];
-/** A labeled mono pane — one honest block of recorded text on the muted
- *  ground, flush with its container: standalone it sits on the row like
- *  the file-edit view's diff panes; inside a card the caller insets it
- *  (docs-search). Never a second border. */
 export declare function pane(label: string, text: string): HTMLElement;
-/** A command and its streams as one terminal block — `$ command`, then
- *  stdout, then stderr (quiet, never failure ink: stderr is routine). */
 export declare function terminal(options: {
     command: string | null;
     output?: string;
     stderr?: string;
 }): HTMLElement;
-/** A bounded, scrolling region for a long list inside a card. */
 export declare function scrollRegion(children: readonly HTMLElement[]): HTMLElement;
-/** The hairline card every built-in composes its content into. */
 export declare function card(children: readonly HTMLElement[], title?: string): HTMLElement;
-/** One list row: an optional icon tile, a title line, a muted second
- *  line, and trailing content (a badge, a fact). */
 export declare function listRow(options: {
     title: string;
     secondary?: string;
@@ -27,72 +17,23 @@ export declare function listRow(options: {
     icon?: Element;
     below?: HTMLElement;
 }): HTMLElement;
-/** Property rows: a muted label column and a value column. */
 export declare function factRows(facts: readonly (readonly [label: string, value: string | HTMLElement])[]): HTMLElement;
-/** A quiet caption row inside a card, with optional trailing content. */
 export declare function captionRow(text: string, trailing?: HTMLElement | string): HTMLElement;
-/** A trailing badge on a list row — the vanilla twin of ToolViewBadge,
- *  for the wait on a built-in's proposal row. */
 export declare function badge(text: string): HTMLElement;
-/** Skeleton lines where the result will land — pending is a shape. */
 export declare function boneRows(count: number): HTMLElement;
-/** One quiet sentence in the muted register — for what is absent,
- *  degraded, or not renderable, never for invented structure. */
 export declare function note(text: string): HTMLElement;
 export declare function recordOf(value: unknown): Record<string, unknown> | null;
 export declare function stringOf(value: unknown): string | null;
-/**
- * The lifecycle factory every built-in rides: `render` is a pure
- * function of the props, so a full re-render IS the contract's
- * update-in-place — the state the update law protects is state these
- * views deliberately don't hold. A throw from `render` propagates as
- * the adapter's one failure channel and the slot advances a rung.
- */
 export declare function statelessToolView(render: (props: ToolViewProps) => HTMLElement): ToolViewAdapter;
-/** True when the call settled cleanly with its own recorded output —
- *  the only state in which a built-in may draw a result shape. */
 export declare function settledWithResult(call: ToolViewCall): boolean;
-/**
- * The honesty ladder every built-in applies before any success shape:
- * a call that didn't finish cleanly never wears success furniture, and
- * a result the transcript doesn't hold is said to be missing, never
- * invented. The row narrates these states with richer copy of its own
- * (the pill, the refusal reason, the error pane).
- *
- * REACHABILITY, recorded (re-derived from this function's own switch):
- * the refused, output-error, denied, cancelled, superseded and offloaded
- * arms are REACHABLE in production — tool-row no longer gates output, so
- * a view mounts for the call's whole lifecycle while the view model
- * withholds output on exactly these settles. A still-RUNNING call
- * renders none of them: input-streaming and input-available break out to
- * the empty list below. That is the difference from the action view's
- * deleted ok:false arm, which needed output-available PLUS a failure
- * envelope — a pairing the producers can never emit under any gating.
- */
 export declare function settledOutcomeNotesOf(call: ToolViewCall): HTMLElement[];
-/** The same honesty ladder as one sentence, for React hosts that render
- *  text rather than package DOM — the vocabulary exists once. */
 export declare function settledOutcomeNoteOf(call: ToolViewCall): string | null;
-/** An action call's recorded response: the http_intent success envelope
- *  `{"ok": true, "result": {status, body, truncated}}` that
- *  tool_return_of (toolresultv1.py) serializes whole into resultText.
- *  The core unwrapper hands `call.result` the BODY alone, so the HTTP
- *  status is recoverable only here. Null for anything that is not
- *  exactly this envelope (ok:false shapes included) — a view then says
- *  so, never guesses. Authored knowledge of our own tool's format,
- *  exported so hosts re-use it instead of respelling the parse. */
 export interface ActionEnvelope {
     status: number | null;
     body: unknown;
     truncated: boolean;
 }
 export declare function actionEnvelopeOf(resultText: string | undefined): ActionEnvelope | null;
-/** A failed action call's recorded reason: the failure envelope
- *  `{"ok": false, "error": {code, message, detail?}, instruction}` that
- *  tool_return_of serializes into the call's error text. `detail` is the
- *  API's own account when the adapter's error carried one
- *  (execution-kinds.ts ExecutionFailureDetail). Null for any other text
- *  — the row's own error pane still shows the raw reason. */
 export interface ActionFailure {
     message: string;
     detail: {
@@ -102,22 +43,9 @@ export interface ActionFailure {
             path: string;
             message: string;
         }[];
-        /** Problems the API named beyond `fields` — the producer's cap or
-         *  door fit dropped them from the tail (execution-handlers.ts);
-         *  present only when positive, so a partial list never reads whole. */
         fieldsOmitted?: number;
     } | null;
 }
 export declare function actionFailureOf(errorText: string | undefined): ActionFailure | null;
-/** The member-facing sentence of a recorded failure: the failure
- *  envelope's message with its model-facing parts removed — the
- *  "HTTP 422 CODE — " prefix, the "Field problems: …" clause and the
- *  "Do not assume …" tail — or the error text itself when it is not the
- *  envelope. The status, code and fields stay machine facts a view reads
- *  through actionFailureOf; a row never prints wire vocabulary at a
- *  member. */
 export declare function humanFailureSentenceOf(errorText: string): string;
-/** A document glyph for a row's icon tile (the package's file mark, as
- *  an inline SVG so vanilla built-ins carry no icon dependency). */
 export declare function fileGlyph(): SVGElement;
-//# sourceMappingURL=view-dom.d.ts.map

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

@@ -1,13 +1,3 @@
-// Shared DOM vocabulary for the package's built-in tool views (rung 3,
-// tool-views.md). Vanilla imperative adapters on purpose: the frozen
-// registration table lives in core/tool-view.ts, which is
-// runtime-React-free by design, and these views hold no local UI state
-// — the canonical mount/update/destroy adapter costs nothing and keeps
-// React out of the core closure. The directory is load-bearing: the
-// Tailwind source scan is `@source "../components"` (styles.css), so
-// utility classes referenced outside src/components are never emitted.
-// The class strings are parts-classes.ts — the same vocabulary the React
-// parts (parts.tsx) hand to host views, so ours and theirs are one look.
 import { BADGE_CLASS, BONES_CLASS, BONE_CLASS, CAPTION_ROW_CLASS, CARD_CLASS, CARD_TITLE_CLASS, FACT_LABEL_CLASS, FACT_LIST_CLASS, FACT_ROW_CLASS, FACT_VALUE_CLASS, LABEL_CLASS, NOTE_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS, ROW_CLASS, ROW_ICON_CLASS, ROW_SECONDARY_CLASS, ROW_TEXT_CLASS, ROW_TITLE_CLASS, ROW_TRAIL_CLASS, SCROLL_REGION_CLASS, TERMINAL_CLASS, TERMINAL_OUTPUT_CLASS, TERMINAL_PROMPT_CLASS, TERMINAL_STDERR_CLASS, } from "./parts-classes.js";
 export { LABEL_CLASS, PANE_CLASS, PANE_WRAPPER_CLASS };
 export function el(tag, className, text) {
@@ -20,10 +10,6 @@ export function el(tag, className, text) {
     }
     return node;
 }
-/** A labeled mono pane — one honest block of recorded text on the muted
- *  ground, flush with its container: standalone it sits on the row like
- *  the file-edit view's diff panes; inside a card the caller insets it
- *  (docs-search). Never a second border. */
 export function pane(label, text) {
     const wrapper = el("div", PANE_WRAPPER_CLASS);
     wrapper.append(el("p", LABEL_CLASS, label));
@@ -32,8 +18,6 @@ export function pane(label, text) {
     wrapper.append(pre);
     return wrapper;
 }
-/** A command and its streams as one terminal block — `$ command`, then
- *  stdout, then stderr (quiet, never failure ink: stderr is routine). */
 export function terminal(options) {
     const block = el("pre", TERMINAL_CLASS);
     block.dataset.tfTerminal = "";
@@ -56,14 +40,12 @@ export function terminal(options) {
     }
     return block;
 }
-/** A bounded, scrolling region for a long list inside a card. */
 export function scrollRegion(children) {
     const region = el("div", SCROLL_REGION_CLASS);
     region.dataset.tfScrollRegion = "";
     region.append(...children);
     return region;
 }
-/** The hairline card every built-in composes its content into. */
 export function card(children, title) {
     const wrapper = el("div", "");
     if (title !== undefined) {
@@ -75,8 +57,6 @@ export function card(children, title) {
     wrapper.append(body);
     return wrapper;
 }
-/** One list row: an optional icon tile, a title line, a muted second
- *  line, and trailing content (a badge, a fact). */
 export function listRow(options) {
     const row = el("div", ROW_CLASS);
     if (options.icon !== undefined) {
@@ -100,7 +80,6 @@ export function listRow(options) {
     }
     return row;
 }
-/** Property rows: a muted label column and a value column. */
 export function factRows(facts) {
     const list = el("dl", FACT_LIST_CLASS);
     for (const [label, value] of facts) {
@@ -113,7 +92,6 @@ export function factRows(facts) {
     }
     return list;
 }
-/** A quiet caption row inside a card, with optional trailing content. */
 export function captionRow(text, trailing) {
     const row = el("div", CAPTION_ROW_CLASS);
     row.append(el("span", "tf:min-w-0", text));
@@ -124,12 +102,9 @@ export function captionRow(text, trailing) {
     }
     return row;
 }
-/** A trailing badge on a list row — the vanilla twin of ToolViewBadge,
- *  for the wait on a built-in's proposal row. */
 export function badge(text) {
     return el("span", BADGE_CLASS, text);
 }
-/** Skeleton lines where the result will land — pending is a shape. */
 export function boneRows(count) {
     const wrapper = el("div", BONES_CLASS);
     wrapper.setAttribute("aria-hidden", "true");
@@ -138,8 +113,6 @@ export function boneRows(count) {
     }
     return wrapper;
 }
-/** One quiet sentence in the muted register — for what is absent,
- *  degraded, or not renderable, never for invented structure. */
 export function note(text) {
     return el("p", NOTE_CLASS, text);
 }
@@ -151,13 +124,6 @@ export function recordOf(value) {
 export function stringOf(value) {
     return typeof value === "string" ? value : null;
 }
-/**
- * The lifecycle factory every built-in rides: `render` is a pure
- * function of the props, so a full re-render IS the contract's
- * update-in-place — the state the update law protects is state these
- * views deliberately don't hold. A throw from `render` propagates as
- * the adapter's one failure channel and the slot advances a rung.
- */
 export function statelessToolView(render) {
     return {
         mount(container, props) {
@@ -173,34 +139,13 @@ export function statelessToolView(render) {
         },
     };
 }
-/** True when the call settled cleanly with its own recorded output —
- *  the only state in which a built-in may draw a result shape. */
 export function settledWithResult(call) {
     return call.status === "output-available" && call.offloaded !== true;
 }
-/**
- * The honesty ladder every built-in applies before any success shape:
- * a call that didn't finish cleanly never wears success furniture, and
- * a result the transcript doesn't hold is said to be missing, never
- * invented. The row narrates these states with richer copy of its own
- * (the pill, the refusal reason, the error pane).
- *
- * REACHABILITY, recorded (re-derived from this function's own switch):
- * the refused, output-error, denied, cancelled, superseded and offloaded
- * arms are REACHABLE in production — tool-row no longer gates output, so
- * a view mounts for the call's whole lifecycle while the view model
- * withholds output on exactly these settles. A still-RUNNING call
- * renders none of them: input-streaming and input-available break out to
- * the empty list below. That is the difference from the action view's
- * deleted ok:false arm, which needed output-available PLUS a failure
- * envelope — a pairing the producers can never emit under any gating.
- */
 export function settledOutcomeNotesOf(call) {
     const sentence = settledOutcomeNoteOf(call);
     return sentence === null ? [] : [note(sentence)];
 }
-/** The same honesty ladder as one sentence, for React hosts that render
- *  text rather than package DOM — the vocabulary exists once. */
 export function settledOutcomeNoteOf(call) {
     switch (call.status) {
         case "refused":
@@ -257,8 +202,6 @@ export function actionFailureOf(errorText) {
         parsed = JSON.parse(errorText);
     }
     catch {
-        // The transcript's error channel carries the SENTENCE alone (the
-        // mapper keeps error.message): the facts ride in its words.
         return { message: errorText, detail: _failureDetailInSentence(errorText) };
     }
     const envelope = recordOf(parsed);
@@ -276,19 +219,10 @@ export function actionFailureOf(errorText) {
             _failureDetailInSentence(message),
     };
 }
-/** The failure sentence's grammar, exactly as execution-handlers.ts
- *  writes it: after the frame's own words, a three-digit status (the
- *  producer admits 100–599 and nothing else) and a whitespace-free code
- *  (any casing or punctuation the API spells) before the dash; then the field clause — each path and message a JSON string
- *  literal, `"path": "message"` or a bare `"message"`, joined by "; " —
- *  closed by the model-facing tail. A clause that does not tokenize to
- *  the end is not the producer's and yields no fields, never a guess. */
 const SENTENCE_STATUS = / failed in this page: HTTP (\d{3}) (\S{1,80}) — /;
 const FIELDS_CLAUSE_OPEN = "Field problems: ";
 const FIELDS_CLAUSE_CLOSE = ". Do not assume";
 const JSON_STRING_LITERAL = /^"(?:[^"\\]|\\.)*"/;
-/** The status, code and field problems as the failure sentence spells
- *  them (execution-handlers.ts) — null when the sentence names none. */
 function _failureDetailInSentence(sentence) {
     const status = SENTENCE_STATUS.exec(sentence);
     if (status === null) {
@@ -351,8 +285,6 @@ function _fieldsInClauseOf(sentence) {
 function _jsonStringAt(text, at) {
     return JSON_STRING_LITERAL.exec(text.slice(at))?.[0] ?? null;
 }
-/** A literal the producer never writes (a raw control character inside
- *  the quotes) decodes to nothing rather than throwing. */
 function _decodedStringOf(literal) {
     try {
         const decoded = JSON.parse(literal);
@@ -392,13 +324,6 @@ function _failureDetailRecordOf(value) {
             : {}),
     };
 }
-/** The member-facing sentence of a recorded failure: the failure
- *  envelope's message with its model-facing parts removed — the
- *  "HTTP 422 CODE — " prefix, the "Field problems: …" clause and the
- *  "Do not assume …" tail — or the error text itself when it is not the
- *  envelope. The status, code and fields stay machine facts a view reads
- *  through actionFailureOf; a row never prints wire vocabulary at a
- *  member. */
 export function humanFailureSentenceOf(errorText) {
     const failure = actionFailureOf(errorText);
     const sentence = failure === null ? errorText : failure.message;
@@ -410,8 +335,6 @@ function _beforeMarker(text, marker) {
     const at = text.indexOf(marker);
     return at === -1 ? text : text.slice(0, at);
 }
-/** A document glyph for a row's icon tile (the package's file mark, as
- *  an inline SVG so vanilla built-ins carry no icon dependency). */
 export function fileGlyph() {
     const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
     svg.setAttribute("viewBox", "0 0 24 24");
@@ -435,4 +358,3 @@ export function fileGlyph() {
     }
     return svg;
 }
-//# sourceMappingURL=view-dom.js.map