@peasant-labs/fairtrade 0.0.1 → 0.0.3

package/dist/lib/types/ToolRenderers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ToolCall — one collapsible tool-call row that dispatches on `tool.kind` to its body.
+ *
+ * Collapsed, the row is a real <button> (carries aria-expanded / aria-controls): a tool icon,
+ * the tool name, a one-line arg preview, the duration, and a status word (icon + "ok"/"error",
+ * never color alone). Activating it toggles real open/closed state and reveals the
+ * kind-specific body. An unknown kind keeps the generic wrench icon + the DefaultBody.
+ *
+ * @param {object} props
+ * @param {{kind:string, name:string, args?:object, duration?:number, status?:'ok'|'error'}} props.tool
+ * @param {boolean} [props.defaultOpen=false]  initial open state.
+ * @param {string} [props.className]
+ */
+export default function ToolCall({ tool, defaultOpen, className, ...rest }: {
+    tool: {
+        kind: string;
+        name: string;
+        args?: object;
+        duration?: number;
+        status?: "ok" | "error";
+    };
+    defaultOpen?: boolean;
+    className?: string;
+}): any;

package/dist/lib/types/Tooltip.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @typedef {Object} TooltipProps
+ * @property {React.ReactNode} content    short, single-line helper text shown in the .tip-bubble (role=tooltip).
+ * @property {React.ReactElement} children   the trigger: a single focusable, already-named element (e.g. a button or link). it receives aria-describedby pointing at the bubble.
+ * @property {string} [id]                id for the bubble, linked from the trigger via aria-describedby. auto-generated if omitted.
+ */
+export default function Tooltip({ content, children, id }: {
+    content: any;
+    children: any;
+    id: any;
+}): any;
+/**
+ * @typedef {Object} PopoverProps
+ * @property {React.ReactNode} children   the trigger button content (e.g. an icon + label).
+ * @property {string} label               accessible name for the floating dialog (aria-label on .pop-card).
+ * @property {React.ReactNode} [title]    .pop-title text shown in the .pop-head; defaults to `label`.
+ * @property {import('react').ComponentType} [icon]  lucide icon component for the .pop-head; decorative, sized by css (.pop-head .lucide -> --ic-sm).
+ * @property {React.ReactNode} content    the .pop-body content.
+ * @property {React.ReactNode} [footer]   the .pop-foot content (e.g. cancel / confirm buttons).
+ * @property {string} [triggerClassName]  classes for the trigger button. defaults to "btn btn-secondary btn-sm".
+ * @property {string} [id]                id for the .pop-card, linked from the trigger via aria-controls. auto-generated if omitted.
+ */
+export function Popover({ children, label, title, icon: Icon, content, footer, triggerClassName, id, }: {
+    children: any;
+    label: any;
+    title: any;
+    icon: any;
+    content: any;
+    footer: any;
+    triggerClassName?: string;
+    id: any;
+}): any;
+export type TooltipProps = {
+    /**
+     * short, single-line helper text shown in the .tip-bubble (role=tooltip).
+     */
+    content: React.ReactNode;
+    /**
+     * the trigger: a single focusable, already-named element (e.g. a button or link). it receives aria-describedby pointing at the bubble.
+     */
+    children: React.ReactElement;
+    /**
+     * id for the bubble, linked from the trigger via aria-describedby. auto-generated if omitted.
+     */
+    id?: string;
+};
+export type PopoverProps = {
+    /**
+     * the trigger button content (e.g. an icon + label).
+     */
+    children: React.ReactNode;
+    /**
+     * accessible name for the floating dialog (aria-label on .pop-card).
+     */
+    label: string;
+    /**
+     * .pop-title text shown in the .pop-head; defaults to `label`.
+     */
+    title?: React.ReactNode;
+    /**
+     * lucide icon component for the .pop-head; decorative, sized by css (.pop-head .lucide -> --ic-sm).
+     */
+    icon?: any;
+    /**
+     * the .pop-body content.
+     */
+    content: React.ReactNode;
+    /**
+     * the .pop-foot content (e.g. cancel / confirm buttons).
+     */
+    footer?: React.ReactNode;
+    /**
+     * classes for the trigger button. defaults to "btn btn-secondary btn-sm".
+     */
+    triggerClassName?: string;
+    /**
+     * id for the .pop-card, linked from the trigger via aria-controls. auto-generated if omitted.
+     */
+    id?: string;
+};

package/dist/lib/types/Tour.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tour — a portal-rendered spotlight coachmark over real page anchors.
+ *
+ * controlled by `open`; `onClose` fires on esc / skip / scrim-intent, and
+ * `onFinish` fires when "done" is pressed on the last step. internal step index
+ * is owned here and re-armed to 0 each time the tour (re)opens.
+ *
+ * @param {Object} props
+ * @param {TourStep[]} props.steps          ordered steps; each spotlights one anchor
+ * @param {boolean} props.open              whether the tour is mounted / visible
+ * @param {() => void} [props.onClose]      called on esc / skip / scrim (tour dismissed)
+ * @param {() => void} [props.onFinish]     called when "done" is pressed on the last step
+ * @param {(index: number) => void} [props.onStepChange]  notified when the active step changes
+ * @param {string} [props.labelId='tour-title']  id wiring aria-labelledby on the coachmark
+ */
+export default function Tour({ steps, open, onClose, onFinish, onStepChange, labelId, }: {
+    steps: TourStep[];
+    open: boolean;
+    onClose?: () => void;
+    onFinish?: () => void;
+    onStepChange?: (index: number) => void;
+    labelId?: string;
+}): any;
+export type TourStep = {
+    /**
+     * id (or data-tour value) of the element to spotlight
+     */
+    anchorId: string;
+    /**
+     * the coachmark title (display type)
+     */
+    title: React.ReactNode;
+    /**
+     * the coachmark prose body (reading type)
+     */
+    body: React.ReactNode;
+};

package/dist/lib/types/TranscriptMarkers.d.ts

@@ -0,0 +1,50 @@
+export function PhaseDivider({ label, range, active, stickyTop, onClick, className, ...rest }: {
+    [x: string]: any;
+    label: any;
+    range: any;
+    active?: boolean;
+    stickyTop?: string;
+    onClick: any;
+    className?: string;
+}): any;
+export function Phase({ label, range, active, stickyTop, onLabelClick, children, className, ...rest }: {
+    [x: string]: any;
+    label: any;
+    range: any;
+    active?: boolean;
+    stickyTop?: string;
+    onLabelClick: any;
+    children: any;
+    className?: string;
+}): any;
+export function TaskBoundary({ turn, duration, tools, files, ins, del, className, ...rest }: {
+    [x: string]: any;
+    turn: any;
+    duration: any;
+    tools: any;
+    files: any;
+    ins?: number;
+    del?: number;
+    className?: string;
+}): any;
+export function CheckpointMarker({ hash, message, time, files, ins, del, className, ...rest }: {
+    [x: string]: any;
+    hash: any;
+    message: any;
+    time: any;
+    files: any;
+    ins?: number;
+    del?: number;
+    className?: string;
+}): any;
+export function TurnContextBar({ prompt, ordinal, onNext, nextLabel, stickyTop, onJump, className, ...rest }: {
+    [x: string]: any;
+    prompt: any;
+    ordinal: any;
+    onNext: any;
+    nextLabel?: string;
+    stickyTop?: string;
+    onJump: any;
+    className?: string;
+}): any;
+export default TaskBoundary;

package/dist/lib/types/Treemap.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Lay `items` out as a squarified treemap filling [0,0,width,height]. Returns one
+ * tile per item (input length preserved). Zero/negative-value items get zero-size
+ * tiles (no area, so they never overlap). When every value is 0, values fall back
+ * to equal (so a no-churn set still tiles legibly). A non-positive width or height
+ * yields all-zero tiles (no NaN/Infinity).
+ *
+ * @param {Array<{id:string, value:number}>} items
+ * @param {number} width
+ * @param {number} height
+ * @returns {Array<{id:string, x:number, y:number, w:number, h:number}>}
+ */
+export function squarify(items: Array<{
+    id: string;
+    value: number;
+}>, width: number, height: number): Array<{
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+/**
+ * @typedef {Object} TreemapDatum
+ * @property {string} id                 stable key (also the default selection token)
+ * @property {string} label              human label, e.g. "ingest/stream.go" (leaf shown)
+ * @property {number} value              non-negative sizing weight; tile AREA ∝ value
+ * @property {number} [intensity=0]      0..4 monochrome ramp level (a SECOND metric)
+ * @property {string} [unit='lines']     noun for the aria-label, e.g. "lines", "calls"
+ */
+/**
+ * Treemap — a squarified, strict-monochrome treemap. One tile per datum, AREA
+ * proportional to `value`, an optional 0..4 grayscale `intensity` reinforcing a
+ * second metric. No hue, no verdict — facts for orientation. Each tile is a real
+ * <button> (label + aria-label "<label> — N <unit>"), focus-visible ring, and a
+ * title, so sliver tiles whose label is suppressed stay identifiable. Clicking a
+ * tile fires `onSelect(id, datum)`.
+ *
+ * Emits a `role="group"` container so the interactive tiles stay in the a11y tree
+ * (role="img" would make them presentational). Renders nothing for an empty set.
+ *
+ * @param {Object} props
+ * @param {TreemapDatum[]} [props.data=[]]              the tiles (area ∝ value)
+ * @param {(id:string, datum:TreemapDatum)=>void} [props.onSelect]  fired on tile click
+ * @param {number} [props.height=320]                   container height in px
+ * @param {string} [props.ariaLabel]                    label for the group landmark
+ * @param {string} [props.className]                    extra class on the container
+ */
+export default function Treemap({ data, onSelect, height, ariaLabel, className, }: {
+    data?: TreemapDatum[];
+    onSelect?: (id: string, datum: TreemapDatum) => void;
+    height?: number;
+    ariaLabel?: string;
+    className?: string;
+}): any;
+export type TreemapDatum = {
+    /**
+     * stable key (also the default selection token)
+     */
+    id: string;
+    /**
+     * human label, e.g. "ingest/stream.go" (leaf shown)
+     */
+    label: string;
+    /**
+     * non-negative sizing weight; tile AREA ∝ value
+     */
+    value: number;
+    /**
+     * 0..4 monochrome ramp level (a SECOND metric)
+     */
+    intensity?: number;
+    /**
+     * noun for the aria-label, e.g. "lines", "calls"
+     */
+    unit?: string;
+};

package/dist/lib/types/VisibilityControl.d.ts

@@ -0,0 +1,54 @@
+/**
+ * VisibilityEye — a compact glyph that signals a transcript's visibility, with a tooltip naming the
+ * exact mode on hover / focus. Eye = public, EyeOff = private, Users = shared. The glyph is paired
+ * with a visually-hidden word so the state never reads on shape or color alone.
+ *
+ * @param {{ visibility?: 'public'|'private'|'shared', sharedWith?: string, size?: 'sm'|'md'|'lg' }} props
+ */
+export function VisibilityEye({ visibility, sharedWith, size }: {
+    visibility?: "public" | "private" | "shared";
+    sharedWith?: string;
+    size?: "sm" | "md" | "lg";
+}): any;
+/**
+ * VisibilitySegmented — a private | public segmented control with a one-line description under each
+ * option, and an optional "shared" override note when the server owns the state. The pressed option
+ * carries aria-pressed + a leading icon + the amber selected fill, so the choice is never color-only.
+ *
+ * @param {{ value?: 'public'|'private'|'shared', onChange?: (v:'public'|'private')=>void,
+ *           sharedNote?: string, label?: string }} props
+ */
+export function VisibilitySegmented({ value, onChange, sharedNote, label, }: {
+    value?: "public" | "private" | "shared";
+    onChange?: (v: "public" | "private") => void;
+    sharedNote?: string;
+    label?: string;
+}): any;
+/**
+ * ScopeChip — a small toggle group scoping a view to task / file / change (a chip set). One chip is
+ * pressed at a time; the pressed chip carries aria-pressed + the selected fill, so the active scope
+ * never reads on color alone.
+ *
+ * @param {{ scope?: string, onChange?: (v:string)=>void,
+ *           options?: {value:string,label:string}[], label?: string }} props
+ */
+export function ScopeChip({ scope, onChange, options, label }: {
+    scope?: string;
+    onChange?: (v: string) => void;
+    options?: {
+        value: string;
+        label: string;
+    }[];
+    label?: string;
+}): any;
+/**
+ * FocusedModeToggle — a single toggle button for "focused" mode (your prompts & the assistant's
+ * replies only). Carries aria-pressed + an icon + the word, so the on / off state is never color-only.
+ *
+ * @param {{ on?: boolean, onToggle?: (next:boolean)=>void }} props
+ */
+export function FocusedModeToggle({ on, onToggle }: {
+    on?: boolean;
+    onToggle?: (next: boolean) => void;
+}): any;
+export default VisibilitySegmented;

package/dist/lib/types/chart-shared.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ChartFrame - the hairline card chrome shared by ChartBar + ChartLine: an optional head
+ * (lucide icon + lowercase title + tabular aside), an optional sub line, the plot, and an
+ * optional swatch+label legend.
+ */
+export function ChartFrame({ icon: Icon, title, aside, sub, legend, className, children }: {
+    icon: any;
+    title: any;
+    aside: any;
+    sub: any;
+    legend: any;
+    className?: string;
+    children: any;
+}): any;
+/**
+ * ChartTooltip - the custom Recharts tooltip content: a square bordered chip, lowercase mono
+ * key, tabular values, each row prefixed by its series swatch (colour + label, never colour alone).
+ */
+export function ChartTooltip({ active, payload, label, labelFormatter, valueFormatter }: {
+    active: any;
+    payload: any;
+    label: any;
+    labelFormatter: any;
+    valueFormatter: any;
+}): any;
+export function resolveSeries(series: any): any;
+export const SERIES_CLASS: {
+    teal: string;
+    olive: string;
+    clay: string;
+    mauve: string;
+    amber: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+export const SERIES_VAR: {
+    teal: string;
+    olive: string;
+    clay: string;
+    mauve: string;
+    amber: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+export const RAMP: string[];
+export function seriesClass(color: any): any;
+export function seriesVar(color: any): any;
+export function cartesianProps(): {
+    accessibilityLayer: boolean;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+};
+export namespace noAnim {
+    let isAnimationActive: boolean;
+}

package/dist/lib/types/icons.d.ts

@@ -0,0 +1 @@
+export * from 'lucide-react'

package/dist/lib/types/index.d.ts

@@ -0,0 +1,55 @@
+export { default as Switch } from "./Switch.jsx";
+export { default as Tabs } from "./Tabs.jsx";
+export { default as Pager } from "./Pager.jsx";
+export { default as Pagination } from "./Pagination.jsx";
+export { default as Menu } from "./Menu.jsx";
+export { default as EmptyState } from "./EmptyState.jsx";
+export { default as DataTable } from "./DataTable.jsx";
+export { default as ChartBar } from "./ChartBar.jsx";
+export { default as ChartLine } from "./ChartLine.jsx";
+export { default as Sparkline } from "./Sparkline.jsx";
+export { default as Accordion } from "./Accordion.jsx";
+export { default as Dialog } from "./Dialog.jsx";
+export { default as CommandPalette } from "./CommandPalette.jsx";
+export { default as CommitGraph } from "./CommitGraph.jsx";
+export { default as DiffView } from "./DiffView.jsx";
+export { default as TimeStrip } from "./TimeStrip.jsx";
+export { default as PolicySelect } from "./PolicySelect.jsx";
+export { default as MapCanvas } from "./MapCanvas.jsx";
+export { default as StepsWaterfall } from "./StepsWaterfall.jsx";
+export { default as GroupedMultiSelect } from "./GroupedMultiSelect.jsx";
+export { default as ToolCallRenderer } from "./ToolRenderers.jsx";
+export { default as Tour } from "./Tour.jsx";
+export { default as FacetRail } from "./FacetRail.jsx";
+export * from "./transcript/index.js";
+export * from "./transcript/graph/index.js";
+export { default as Button, ButtonGroup, Segmented } from "./Button.jsx";
+export { default as Input, Textarea, Select, Field } from "./Input.jsx";
+export { default as Checkbox, Radio, RadioGroup } from "./Checkbox.jsx";
+export { default as Chip, FilterChip, StatusDot, CountBadge } from "./Chip.jsx";
+export { default as Card, CardImg, Row, MetaItem } from "./Card.jsx";
+export { default as Breadcrumb, Steps } from "./Breadcrumb.jsx";
+export { default as Tooltip, Popover } from "./Tooltip.jsx";
+export { Avatar, AvatarGroup, Kbd, KbdChord, Tag } from "./Avatar.jsx";
+export { default as BrandMark, resolveBrand } from "./BrandMark.jsx";
+export { Skeleton, Progress, Spinner, Toast, FeedbackPanel } from "./Feedback.jsx";
+export { default as Timeline, TimelineItem, ToolCall, ThinkingBlock } from "./Timeline.jsx";
+export { default as ToastProvider, useToast } from "./ToastHost.jsx";
+export { default as DateRange, DateRangeCalendar, formatRange, DATE_PRESETS } from "./DateRange.jsx";
+export { default as MapNode, IntensitySwatch, RampLegend, Heatmap, IntensityScope, coverageLevel, effortLevel, locSize } from "./Intensity.jsx";
+export { default as Treemap, squarify } from "./Treemap.jsx";
+export { default as StepWizard, StepIndicator } from "./StepWizard.jsx";
+export { default as Explainer, Term } from "./Explainer.jsx";
+export { default as RedactionReview, WhereDoesThisGo } from "./Redaction.jsx";
+export { default as ConsentDialog, ConsentSummary } from "./ConsentDialog.jsx";
+export { default as ModerationQueue, ApprovalBar } from "./ModerationQueue.jsx";
+export { default as RoleRoster, ConfirmInline, DangerZone } from "./RoleRoster.jsx";
+export { default as RailShell, RailSection, SplitRail } from "./RailShell.jsx";
+export { default as ProviderIcon, ProviderTag, ProviderName, AccentLegend, PROVIDER_ACCENT } from "./ProviderIcon.jsx";
+export { default as EvidenceCaption, EvidenceTarget } from "./EvidenceCaption.jsx";
+export { PhaseDivider, Phase, TaskBoundary, CheckpointMarker, TurnContextBar } from "./TranscriptMarkers.jsx";
+export { default as ConnectionPill, DataState, TeachingEmptyState } from "./ConnectionState.jsx";
+export { default as SignInProviders, HandleClaim, OnboardingCard } from "./SignIn.jsx";
+export { default as CliSteps, CommandBlock, GettingStarted } from "./CliOnboard.jsx";
+export { StatTile, StatGrid, GovTile, ProviderBars } from "./StatTiles.jsx";
+export { default as VisibilitySegmented, VisibilityEye, ScopeChip, FocusedModeToggle } from "./VisibilityControl.jsx";

package/dist/lib/types/transcript/CheckRow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {object} props
+ * @param {boolean} [props.checked]
+ * @param {Function} [props.onChange]   fired with the native change event
+ * @param {*} [props.children]          the row label (text, or icon + text)
+ * @param {number} [props.count]        optional trailing match count
+ * @param {boolean} [props.disabled]
+ */
+export default function CheckRow({ checked, onChange, children, count, disabled }: {
+    checked?: boolean;
+    onChange?: Function;
+    children?: any;
+    count?: number;
+    disabled?: boolean;
+}): any;

package/dist/lib/types/transcript/DiffEntryCard.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {import('./view-model.js').DiffEntryVM} DiffEntryVM */
+/** @typedef {import('./view-model.js').DiffHunkVM} DiffHunkVM */
+/**
+ * Render cooked diff hunks as the canonical `.txn-diff` rows. The mockup draws a single
+ * `.diff` block per change, so hunks are flattened into one row list; each hunk's trailing
+ * empty line (the LCS newline artifact) is trimmed first.
+ * @param {object} props
+ * @param {DiffHunkVM[]} [props.hunks]
+ */
+export function DiffHunks({ hunks }: {
+    hunks?: DiffHunkVM[];
+}): any;
+/**
+ * One Diffs-tab card: a file/turn label, the +adds/−dels churn, a jump affordance, and the
+ * rendered diff hunks. Consumes a cooked `DiffEntryVM` (an entry of `vm.diffs`).
+ * @param {object} props
+ * @param {DiffEntryVM} [props.entry]
+ * @param {boolean} [props.byTurn]      label by turn index instead of file path
+ * @param {() => void} [props.onJump]
+ */
+export default function DiffEntryCard({ entry, byTurn, onJump }: {
+    entry?: DiffEntryVM;
+    byTurn?: boolean;
+    onJump?: () => void;
+}): any;
+export type DiffEntryVM = import("./view-model.js").DiffEntryVM;
+export type DiffHunkVM = import("./view-model.js").DiffHunkVM;

package/dist/lib/types/transcript/FilterSection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {*} [props.title]              the section heading (lowercase chrome)
+ * @param {*} [props.children]           the section body (rows)
+ * @param {boolean} [props.defaultOpen]
+ */
+export default function FilterSection({ title, children, defaultOpen }: {
+    title?: any;
+    children?: any;
+    defaultOpen?: boolean;
+}): any;

package/dist/lib/types/transcript/FiltersRail.d.ts

@@ -0,0 +1,41 @@
+export default function FiltersRail({ tab, filters, onFiltersChange, counts, checkpoints, filtersActive, onClear, onJumpStart, onJumpLatest, }: {
+    tab: any;
+    filters?: {
+        categories: {
+            prompts: boolean;
+            responses: boolean;
+            thinking: boolean;
+            toolcalls: boolean;
+        };
+        toolGroups: {};
+        tags: {
+            errors: boolean;
+            retries: boolean;
+            revert: boolean;
+        };
+        views: {
+            hidden: boolean;
+            expandAll: boolean;
+            compact: boolean;
+        };
+        checkpoint: string;
+    };
+    onFiltersChange?: () => void;
+    counts?: {
+        categories: {
+            prompts: number;
+            responses: number;
+            thinking: number;
+            toolcalls: number;
+        };
+        toolGroups: {};
+    };
+    checkpoints?: any[];
+    filtersActive?: number;
+    onClear?: () => void;
+    onJumpStart?: () => void;
+    onJumpLatest?: () => void;
+}): any;
+export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;
+export type ToolGroup = import("./view-model.js").ToolGroup;
+export type CommitVM = import("./view-model.js").CommitVM;

package/dist/lib/types/transcript/LabelPopover.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {object} props
+ * @param {number} [props.turnId]                                  the turn index being labelled
+ * @param {SavedLabel} [props.current]                             the existing label, if any
+ * @param {(outcome: SavedLabel['outcome'], flag: string) => void} [props.onSave]
+ * @param {Function} [props.onClose]
+ */
+export default function LabelPopover({ turnId, current, onSave, onClose }: {
+    turnId?: number;
+    current?: SavedLabel;
+    onSave?: (outcome: SavedLabel["outcome"], flag: string) => void;
+    onClose?: Function;
+}): any;
+export type SavedLabel = import("./state-capabilities.js").SavedLabel;

package/dist/lib/types/transcript/Markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {object} props
+ * @param {string} [props.text]   the cooked markdown body (e.g. `TurnVM.content`)
+ */
+export default function Markdown({ text }: {
+    text?: string;
+}): any;

package/dist/lib/types/transcript/OutlineRail.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {TranscriptViewModel} props.viewModel
+ * @param {import('./state-capabilities.js').TranscriptTab} props.tab
+ * @param {(turnIndex: number) => void} [props.onJump]
+ */
+export default function OutlineRail({ viewModel, tab, onJump }: {
+    viewModel: TranscriptViewModel;
+    tab: import("./state-capabilities.js").TranscriptTab;
+    onJump?: (turnIndex: number) => void;
+}): any;
+export type TranscriptViewModel = import("./view-model.js").TranscriptViewModel;
+export type AnnotationVM = import("./view-model.js").AnnotationVM;

package/dist/lib/types/transcript/Scorecard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {object} props
+ * @param {ScorecardBandVM[]} [props.bands]   the cooked scorecard bands (vm.analytics.scorecardBands)
+ */
+export default function Scorecard({ bands }: {
+    bands?: ScorecardBandVM[];
+}): any;
+export type ScorecardBandVM = import("./view-model.js").ScorecardBandVM;

package/dist/lib/types/transcript/Scrubber.d.ts

@@ -0,0 +1,17 @@
+/** @typedef {import('./view-model.js').TurnVM} TurnVM */
+/**
+ * @param {object} props
+ * @param {TurnVM[]} [props.turns]
+ * @param {number} [props.active]                          the active TURN INDEX (TurnVM.index)
+ * @param {(clientX: number, track: HTMLElement) => void} [props.onSeek]
+ * @param {{ current: boolean }} [props.draggingRef]       shared drag latch; defaults to an internal ref
+ */
+export default function Scrubber({ turns, active, onSeek, draggingRef }: {
+    turns?: TurnVM[];
+    active?: number;
+    onSeek?: (clientX: number, track: HTMLElement) => void;
+    draggingRef?: {
+        current: boolean;
+    };
+}): any;
+export type TurnVM = import("./view-model.js").TurnVM;

package/dist/lib/types/transcript/TaskBody.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {object} props
+ * @param {ToolCallVM} [props.tool]
+ */
+export default function TaskBody({ tool }: {
+    tool?: ToolCallVM;
+}): any;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;

package/dist/lib/types/transcript/Thinking.d.ts

@@ -0,0 +1,9 @@
+/** @typedef {import('./view-model.js').ThinkingVM} ThinkingVM */
+/**
+ * @param {object} props
+ * @param {ThinkingVM} [props.block]   cooked thinking (e.g. `TurnVM.thinking`)
+ */
+export default function Thinking({ block }: {
+    block?: ThinkingVM;
+}): any;
+export type ThinkingVM = import("./view-model.js").ThinkingVM;

package/dist/lib/types/transcript/ToolBody.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {object} props
+ * @param {ToolCallVM} [props.tool]
+ */
+export default function ToolBody({ tool }: {
+    tool?: ToolCallVM;
+}): any;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;

package/dist/lib/types/transcript/ToolCall.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {object} props
+ * @param {ToolCallVM} [props.tool]
+ * @param {boolean} [props.open]
+ * @param {() => void} [props.onToggle]
+ */
+export default function ToolCall({ tool, open, onToggle }: {
+    tool?: ToolCallVM;
+    open?: boolean;
+    onToggle?: () => void;
+}): any;
+export type ToolCallVM = import("./view-model.js").ToolCallVM;

package/dist/lib/types/transcript/TranscriptViewer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TranscriptViewerProps} props
+ */
+export default function TranscriptViewer({ viewModel, capabilities, callbacks, theme: themeProp, onThemeChange, graphSlot, activeTab: activeTabProp, onTabChange, viewMode: viewModeProp, onViewModeChange, leftRailOpen: leftRailOpenProp, onLeftRailOpenChange, rightRailOpen: rightRailOpenProp, onRightRailOpenChange, openTools: openToolsProp, onOpenToolsChange, activeTurn: activeTurnProp, onActiveTurnChange, search: searchProp, onSearchChange, filters: filtersProp, onFiltersChange, savedLabels: savedLabelsProp, onSavedLabelsChange, shareOpen: shareOpenProp, onShareOpenChange, moreOpen: moreOpenProp, onMoreOpenChange, }: TranscriptViewerProps): any;
+export type TranscriptViewerProps = import("./state-capabilities.js").TranscriptViewerProps;
+export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;