@peasant-labs/fairtrade 0.0.62 → 0.0.63

package/dist/lib/share.js

@@ -1,6 +1,6 @@
 import { _ as e, c as t, g as n, h as r, m as i, p as a, v as o } from "./time-CpVBzcqQ.js";
 import { r as s } from "./format-B3uT2wzU.js";
-import { c, s as l, t as u } from "./adapter-BSfSbqWE.js";
+import { l as c, t as l, u } from "./adapter-ChziRV1K.js";
 import { jsx as d, jsxs as f } from "react/jsx-runtime";
 //#region public/tokens.json
 var p = {
@@ -556,7 +556,7 @@ function y(e) {
 	return s(e);
 }
 function ce(e, t) {
-	return l({
+	return c({
 		title: typeof e.title == "string" && e.title.trim() !== "" ? e.title.trim() : void 0,
 		hasNormalizedEvidence: t.session.hasNormalizedEvidence,
 		firstTaskPrompt: t.tasks?.[0]?.prompt,
@@ -570,11 +570,11 @@ function le(e) {
 	if (typeof n.harness != "string" || !Array.isArray(n.turns)) return null;
 	let r;
 	try {
-		r = u(n);
+		r = l(n);
 	} catch {
 		return null;
 	}
-	let i = r.session, a = ce(n, r), o = typeof i.harness == "string" ? i.harness : "", s = oe(o) ? t[o] : null, l = n.turns.find((e) => e?.role === "user" && (e.depth ?? 0) === 0), d = typeof l?.content == "string" ? l.content : "", f = ae(i.harness === "cursor" ? c(d) : d).trim(), p = f || a, m = i.inputSubmissionCount, h = i.totalTokens, g = !r.usageScopes?.length && h != null, _ = m != null && g ? {
+	let i = r.session, a = ce(n, r), o = typeof i.harness == "string" ? i.harness : "", s = oe(o) ? t[o] : null, c = n.turns.find((e) => e?.role === "user" && (e.depth ?? 0) === 0), d = typeof c?.content == "string" ? c.content : "", f = ae(i.harness === "cursor" ? u(d) : d).trim(), p = f || a, m = i.inputSubmissionCount, h = i.totalTokens, g = !r.usageScopes?.length && h != null, _ = m != null && g ? {
 		prompts: Number(m),
 		tokens: Number(h)
 	} : null;

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

@@ -1,17 +1,31 @@
 /** @typedef {import('./view-model.js').TurnVM} TurnVM */
 /**
  * @param {object} props
- * @param {TurnVM[]} [props.turns]
+ * @param {TurnVM[]} [props.turns]                         legacy turn mode
+ * @param {ScrubberTick[]} [props.ticks]                   segment sample; takes precedence over `turns`
  * @param {number} [props.active]                          the active TURN INDEX (TurnVM.index)
+ * @param {number} [props.activeTick]                      the active SEGMENT INDEX when `ticks` is supplied
  * @param {(clientX: number, track: HTMLElement) => void} [props.onSeek]
+ * @param {(tick: ScrubberTick) => void} [props.onSeekTick]
  * @param {{ current: boolean }} [props.draggingRef]       shared drag latch; defaults to an internal ref
  */
-export default function Scrubber({ turns, active, onSeek, draggingRef }: {
+export default function Scrubber({ turns, ticks, active, activeTick, onSeek, onSeekTick, draggingRef }: {
     turns?: TurnVM[];
+    ticks?: ScrubberTick[];
     active?: number;
+    activeTick?: number;
     onSeek?: (clientX: number, track: HTMLElement) => void;
+    onSeekTick?: (tick: ScrubberTick) => void;
     draggingRef?: {
         current: boolean;
     };
 }): import("react").JSX.Element;
 export type TurnVM = import("./view-model.js").TurnVM;
+export type ScrubberTick = {
+    key: string;
+    index: number;
+    firstTurn: number;
+    lastTurn: number;
+    label: string;
+    leftPct: number;
+};

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

@@ -0,0 +1,20 @@
+/**
+ * @param {object} props
+ * @param {SegmentBoundaryVM} props.boundary
+ * @param {(segmentIndex: number) => void} [props.onLoadMore]
+ * @param {boolean} [props.loading]        the host is fetching the adjacent segment
+ */
+export default function TranscriptBoundary({ boundary, onLoadMore, loading }: {
+    boundary: SegmentBoundaryVM;
+    onLoadMore?: (segmentIndex: number) => void;
+    loading?: boolean;
+}): import("react").JSX.Element;
+/** @typedef {import('./segments.js').SegmentBoundaryVM} SegmentBoundaryVM */
+/** Thrown when a host mounts the boundary without the unloaded-edge descriptor. */
+export class TranscriptSegmentBoundaryError extends Error {
+    /**
+     * @param {string} message
+     */
+    constructor(message: string);
+}
+export type SegmentBoundaryVM = import("./segments.js").SegmentBoundaryVM;

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

@@ -1,7 +1,7 @@
 /**
  * @param {TranscriptViewerProps} props
  */
-export default function TranscriptViewer({ viewModel, capabilities, callbacks, theme: themeProp, onThemeChange, graphSlot, activeTab: activeTabProp, onTabChange, viewMode: viewModeProp, onViewModeChange, sidebarLayout: sidebarLayoutProp, onSidebarLayoutChange, zen: zenProp, onZenChange, readerWidth: readerWidthProp, onReaderWidthChange, leftRailOpen: leftRailOpenProp, onLeftRailOpenChange, rightRailOpen: rightRailOpenProp, onRightRailOpenChange, openTools: openToolsProp, onOpenToolsChange, earlierHistoryOpen: earlierHistoryOpenProp, onEarlierHistoryOpenChange, initialPosition: initialPositionProp, activeTurn: activeTurnProp, onActiveTurnChange, search: searchProp, onSearchChange, filters: filtersProp, onFiltersChange, savedLabels: savedLabelsProp, onSavedLabelsChange, shareOpen: shareOpenProp, onShareOpenChange, moreOpen: moreOpenProp, onMoreOpenChange, breadcrumb, breadcrumbContext, beforeHeader, LinkComponent, renderTurnPanel, renderTurnActions, anchorHref, headerActions, utilityActions, streamPrelude, showTail, showOutcome, showSearchTrigger, footer, presentation, subtitle, pullRequests, headingLevel, integrity, transcriptContentHash, contentHash, }: TranscriptViewerProps): import("react").JSX.Element;
+export default function TranscriptViewer({ viewModel, capabilities, callbacks, theme: themeProp, onThemeChange, graphSlot, activeTab: activeTabProp, onTabChange, viewMode: viewModeProp, onViewModeChange, sidebarLayout: sidebarLayoutProp, onSidebarLayoutChange, zen: zenProp, onZenChange, readerWidth: readerWidthProp, onReaderWidthChange, leftRailOpen: leftRailOpenProp, onLeftRailOpenChange, rightRailOpen: rightRailOpenProp, onRightRailOpenChange, openTools: openToolsProp, onOpenToolsChange, earlierHistoryOpen: earlierHistoryOpenProp, onEarlierHistoryOpenChange, initialPosition: initialPositionProp, activeTurn: activeTurnProp, onActiveTurnChange, search: searchProp, onSearchChange, filters: filtersProp, onFiltersChange, savedLabels: savedLabelsProp, onSavedLabelsChange, shareOpen: shareOpenProp, onShareOpenChange, moreOpen: moreOpenProp, onMoreOpenChange, breadcrumb, breadcrumbContext, beforeHeader, LinkComponent, renderTurnPanel, renderTurnActions, anchorHref, headerActions, utilityActions, streamPrelude, showTail, showOutcome, showSearchTrigger, footer, presentation, subtitle, pullRequests, headingLevel, integrity, transcriptContentHash, contentHash, directory, segments: segmentsProp, window: windowProp, onLoadSegment, onLoadWindow, }: TranscriptViewerProps): import("react").JSX.Element;
 export const READER_FULL: "full";
 export type TranscriptViewerProps = import("./state-capabilities.js").TranscriptViewerProps;
 export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;

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

@@ -20,6 +20,22 @@ export function thinkingDurationMs(previous: TurnDetail | undefined, turn: TurnD
  * @returns {TurnDetail[]}
  */
 export function prefilterTurns(turns: TurnDetail[]): TurnDetail[];
+/** @param {TurnVM[]} turnVMs @returns {FileEntryVM[]} */
+/**
+ * Aggregate the per-file read/edit/write counts and churn from cooked turns. Shared
+ * by the whole-transcript view model and a segmented viewer's loaded regions, so the
+ * Files tab has one derivation.
+ * @param {TurnVM[]} turnVMs
+ * @returns {FileEntryVM[]}
+ */
+export function buildFiles(turnVMs: TurnVM[]): FileEntryVM[];
+/**
+ * Tool-group counts for a set of cooked turns. Shared by the full filter index and a
+ * segmented viewer's loaded regions.
+ * @param {TurnVM[]} turnVMs
+ * @returns {Record<ToolGroup, number>}
+ */
+export function buildToolGroupCounts(turnVMs: TurnVM[]): Record<ToolGroup, number>;
 /**
  * Project the canonical wire payload (folded turns) into the cooked
  * `TranscriptViewModel` every dumb transcript component renders. The SOLE

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

@@ -22,6 +22,7 @@ export { default as TranscriptCheckRow } from "./CheckRow.jsx";
 export { default as TranscriptViewSwitch } from "./ViewSwitch.jsx";
 export { default as TranscriptMinimap } from "./Minimap.jsx";
 export { default as TranscriptScrubber } from "./Scrubber.jsx";
+export { default as TranscriptSegmentBoundary } from "./TranscriptBoundary.jsx";
 export { default as TranscriptScorecard } from "./Scorecard.jsx";
 export { default as TranscriptLabelPopover } from "./LabelPopover.jsx";
 export { default as useTranscriptInitialPosition } from "./useTranscriptInitialPosition.jsx";
@@ -44,6 +45,12 @@ export type SessionScorecard = import("./wire-types.js").SessionScorecard;
 export type CommitInfo = import("./wire-types.js").CommitInfo;
 export type AnnotationSummary = import("./wire-types.js").AnnotationSummary;
 export type SessionDetailPayload = import("./wire-types.js").SessionDetailPayload;
+export type TranscriptSegmentDirectory = import("./wire-types.js").TranscriptSegmentDirectory;
+export type TranscriptSegmentRef = import("./wire-types.js").TranscriptSegmentRef;
+export type TranscriptSegment = import("./wire-types.js").TranscriptSegment;
+export type TranscriptTurn = import("./wire-types.js").TranscriptTurn;
+export type TranscriptWindow = import("./wire-types.js").TranscriptWindow;
+export type SessionDetailHeaderPayload = import("./wire-types.js").SessionDetailHeaderPayload;
 export type TranscriptWireInput = import("./wire-types.js").TranscriptWireInput;
 export type TranscriptViewerProps = import("./state-capabilities.js").TranscriptViewerProps;
 export type TranscriptInitialPosition = import("./state-capabilities.js").TranscriptInitialPosition;
@@ -59,6 +66,12 @@ export type Presentation = import("./state-capabilities.js").Presentation;
 export type TranscriptTab = import("./state-capabilities.js").TranscriptTab;
 export type ViewMode = import("./state-capabilities.js").ViewMode;
 export type TranscriptViewModel = import("./view-model.js").TranscriptViewModel;
+export type SegmentDirectoryVM = import("./segments.js").SegmentDirectoryVM;
+export type SegmentRefVM = import("./segments.js").SegmentRefVM;
+export type SegmentVM = import("./segments.js").SegmentVM;
+export type SegmentWindowVM = import("./segments.js").SegmentWindowVM;
+export type SegmentRegionVM = import("./segments.js").SegmentRegionVM;
+export type SegmentBoundaryVM = import("./segments.js").SegmentBoundaryVM;
 export type RelationshipVM = import("./view-model.js").RelationshipVM;
 export type EarlierHistoryVM = import("./view-model.js").EarlierHistoryVM;
 export type AdaptTranscriptOptions = import("./adapter.js").AdaptTranscriptOptions;
@@ -82,10 +95,11 @@ export type PhaseVM = import("./view-model.js").PhaseVM;
 export type ScorecardBandVM = import("./view-model.js").ScorecardBandVM;
 export type TranscriptAnalyticsVM = import("./view-model.js").TranscriptAnalyticsVM;
 export { ROLES, ENTRY_TYPES, TOOL_CALL_KINDS, STOP_REASONS, SESSION_OUTCOMES, HARNESSES } from "./wire-types.js";
-export { adaptTranscript, prefilterTurns, diffLines } from "./adapter.js";
+export { adaptTranscript, prefilterTurns, diffLines, buildFiles, buildToolGroupCounts } from "./adapter.js";
 export { computeTasks, computeTurnLabels, buildTaskWaterfall, annotateTranscript, computePersonalMedians, detectPhases, assessScorecard, computeAnalytics, computeTaskGroups, phaseLabel } from "./analytics.js";
 export { formatRelative, formatDurationMins, formatDurationMs, formatDurationSeconds, formatDateLong, isKnownTime } from "./time.js";
 export { summarizePrompt, composeSessionTitle, projectLabel, cleanSessionTitle, unwrapUserQuery } from "./title.js";
 export { default as TranscriptDiffEntryCard, DiffHunks as TranscriptDiffHunks } from "./DiffEntryCard.jsx";
 export { default as TranscriptViewer, READER_FULL } from "./TranscriptViewer.jsx";
+export { SEGMENT_SCRUBBER_TICKS, SEGMENT_OVERSCAN_TURNS, boundaryCaption, formatByteExtent, loadedFiles, loadedRegions, loadedScope, loadedToolGroupCounts, mountedCardBound, normaliseSegments, regionBoundaries, scrubberTicks, turnsFromSegments, windowCoverage } from "./segments.js";
 export { advanceTranscriptInitialPositionConsumption, normalizeTranscriptInitialPosition, resolveTranscriptInitialPosition, shouldApplyTranscriptInitialPosition, transcriptInitialPositionReadiness, transcriptInitialPositionToken } from "./initial-position.js";

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

@@ -0,0 +1,146 @@
+/** Turn a host's loaded segments into a sorted list. Accepts an array, a record keyed by
+    segment index, or a `Map`; each segment keeps all of its own fields. */
+export function normaliseSegments(segments: any): any[];
+/** The loaded turns, in identity order, without duplicates. A turn is the transport
+    unit's content, so the same identity must never render twice when two loads
+    overlap at a region edge. */
+export function turnsFromSegments(segments: any): any[];
+/** Merge adjacent loaded segments into rendered regions. A segment load that touches a
+    region extends it; a load that does not stays a separate region. */
+export function loadedRegions(directory: any, segments: any): SegmentRegionVM[];
+/**
+ * One boundary per unloaded edge adjacent to a rendered region, in document order.
+ * A gap between two regions gets one boundary with one load-more control (the
+ * proposal's boundary carries one control, not a pager); the control advances the
+ * older region into the gap.
+ *
+ * @param {SegmentDirectoryVM | null | undefined} directory
+ * @param {SegmentRegionVM[]} regions
+ * @returns {SegmentBoundaryVM[]}
+ */
+export function regionBoundaries(directory: SegmentDirectoryVM | null | undefined, regions: SegmentRegionVM[]): SegmentBoundaryVM[];
+/** Human byte extent: the boundary caption's size, and the truncation notice's own. */
+export function formatByteExtent(bytes: any): string;
+/** The boundary's caption: the unloaded extent on that side, in turns, segments and bytes. */
+export function boundaryCaption(boundary: any): string;
+/** The fixed scrubber sample over the directory. Never one tick per turn. */
+export function scrubberTicks(directory: any): {
+    key: string;
+    index: any;
+    firstTurn: any;
+    lastTurn: any;
+    label: string;
+    leftPct: number;
+}[];
+/** What the trace count and the Files tab have actually read. */
+export function loadedScope(directory: any, regions: any): {
+    loadedSegments: any;
+    totalSegments: number;
+    loadedTurns: any;
+    totalTurns: number;
+    complete: boolean;
+    filesText: string;
+};
+/** Whether every covering segment a window descriptor names is in hand. */
+export function windowCoverage(window: any, segments: any): {
+    required: boolean;
+    complete: boolean;
+    missing: any;
+    indexes: any[];
+};
+/** The mounted-card bound: the turns of the loaded segments, and nothing else. */
+export function mountedCardBound(segments: any): any;
+/** The Files tab derived from the turns in hand: file, read/edit/write counts, churn,
+    and the first loaded turn that touched it. The one derivation lives in `adapter.js`,
+    so a segmented viewer and a whole-transcript view model cannot disagree. */
+export function loadedFiles(turns: any): import("./view-model.js").FileEntryVM[];
+/** Tool-group counts scoped to the turns the viewer actually holds. */
+export function loadedToolGroupCounts(turns: any): Record<import("./view-model.js").ToolGroup, number>;
+/** Whether a turn is a wordless assistant turn: a run of model actions that may have
+    started in a segment the reader has not loaded. */
+export function isWordlessAssistant(turn: any): boolean;
+/** @typedef {import('./view-model.js').TurnVM} TurnVM */
+/** The scrubber's fixed sample size; the mounted tick count is `min(this, totalSegments)`. */
+export const SEGMENT_SCRUBBER_TICKS: 200;
+/** Extra turns a mounted region may draw beyond the turns it was given. The viewer
+    never invents turn content, so the overscan budget stays zero and the bound is the
+    loaded segments' own turns. Named so a surface cannot quietly grow it. */
+export const SEGMENT_OVERSCAN_TURNS: 0;
+export type TurnVM = import("./view-model.js").TurnVM;
+/**
+ * One segment reference from the directory.
+ */
+export type SegmentRefVM = {
+    index: number;
+    firstTurn: number;
+    lastTurn: number;
+    byteLength: number;
+};
+/**
+ * The transcript's only global index.
+ */
+export type SegmentDirectoryVM = {
+    sessionId?: string;
+    revision?: string;
+    totalTurns: number;
+    totalSegments: number;
+    segments?: SegmentRefVM[];
+    directoryPage?: number;
+    directoryPerPage?: number;
+};
+/**
+ * One loaded segment, already cooked to `TurnVM`s.
+ */
+export type SegmentVM = {
+    index: number;
+    firstTurn: number;
+    lastTurn: number;
+    byteLength: number;
+    hasOlder?: boolean;
+    hasNewer?: boolean;
+    turns: TurnVM[];
+};
+/**
+ * A window descriptor. It carries no turn content: only where the window is and
+ * which segments cover it.
+ */
+export type SegmentWindowVM = {
+    sessionId?: string;
+    revision?: string;
+    requestedAnchor: number;
+    anchorTurn: number;
+    span: number;
+    firstTurn: number;
+    lastTurn: number;
+    segments: number[];
+    hasOlder?: boolean;
+    hasNewer?: boolean;
+};
+/**
+ * One contiguous run of loaded segments.
+ */
+export type SegmentRegionVM = {
+    key: string;
+    firstSegment: number;
+    lastSegment: number;
+    firstTurn: number;
+    lastTurn: number;
+    refs: SegmentRefVM[];
+    turns: TurnVM[];
+};
+/**
+ * One unloaded edge in front of a rendered region.
+ */
+export type SegmentBoundaryVM = {
+    key: string;
+    side: "older" | "newer" | "between" | "all";
+    firstTurn: number;
+    lastTurn: number;
+    segmentIndexes: number[];
+    segmentCount: number;
+    byteLength: number;
+    /**
+     * the segment a load-more on this edge appends/prepends
+     */
+    loadSegment: number;
+};

package/dist/lib/types/transcript/state-capabilities.d.ts

@@ -126,6 +126,10 @@ export type ViewerCallbacks = {
      * authorized read target only; host owns current route and Back restoration
      */
     onNavigateRelationship?: (navigation: import("@peasant-labs/schema").SessionRelationshipNavigation) => void;
+    /**
+     * the reader asked for a bounded turn in full; the host performs the existing continuation read and replaces that turn
+     */
+    onLoadFullTurn?: (turnIndex: number) => void;
 };
 /**
  * What the `graphSlot` render-prop receives. The composite owns NO graph engine
@@ -335,6 +339,26 @@ export type TranscriptViewerBaseProps = {
      * the bare hash of the content `viewModel` was cooked from (the content route's `Village-Content-Hash` header). Turns are marked only when it equals `transcriptContentHash` and both are non-empty
      */
     contentHash?: string | null;
+    /**
+     * the transcript's only global index (segment refs, totals, revision). Supplied with `segments`, the viewer renders loaded regions instead of a whole-session turn list
+     */
+    directory?: import("./segments.js").SegmentDirectoryVM | null;
+    /**
+     * the segments the host has loaded, already cooked to `TurnVM`s; the viewer never mounts a turn it was not given
+     */
+    segments?: import("./segments.js").SegmentVM[] | Map<number, import("./segments.js").SegmentVM> | Record<number, import("./segments.js").SegmentVM>;
+    /**
+     * a jump descriptor: where the window is and which covering segments to load. It carries no turn content
+     */
+    window?: import("./segments.js").SegmentWindowVM | null;
+    /**
+     * load one segment; the boundary, the scrubber and a window all request through this one path
+     */
+    onLoadSegment?: (segmentIndex: number) => void | Promise<unknown>;
+    /**
+     * resolve a jump's window descriptor from a turn identity
+     */
+    onLoadWindow?: (anchorTurn: number, span?: number) => void | Promise<unknown>;
 };
 /**
  * The full legacy trail and the ancestor-only context are alternative contracts.

package/dist/lib/types/transcript/view-model.d.ts

@@ -397,6 +397,18 @@ export type TurnVM = {
      * annotations targeting this turn (may be empty)
      */
     annotations: AnnotationVM[];
+    /**
+     * the segment this turn arrived in, when read as part of loaded regions
+     */
+    segmentIndex?: number;
+    /**
+     * this turn's own text was bounded by the served-text bound
+     */
+    truncated?: boolean;
+    /**
+     * pre-bound JSON size of content + arguments + result; the truncation notice's size
+     */
+    byteLength?: number;
 };
 /**
  * A cooked annotation, already resolved to the turn it targets. The adapter maps

package/dist/lib/types/transcript/wire-types.d.ts

@@ -11,6 +11,12 @@
 /** @typedef {import('@peasant-labs/schema').CommitInfo} CommitInfo */
 /** @typedef {import('@peasant-labs/schema').AnnotationSummary} AnnotationSummary */
 /** @typedef {import('@peasant-labs/schema').SessionDetailPayload} SessionDetailPayload */
+/** @typedef {import('@peasant-labs/schema').TranscriptSegmentDirectory} TranscriptSegmentDirectory */
+/** @typedef {import('@peasant-labs/schema').TranscriptSegmentRef} TranscriptSegmentRef */
+/** @typedef {import('@peasant-labs/schema').TranscriptSegment} TranscriptSegment */
+/** @typedef {import('@peasant-labs/schema').TranscriptTurn} TranscriptTurn */
+/** @typedef {import('@peasant-labs/schema').TranscriptWindow} TranscriptWindow */
+/** @typedef {import('@peasant-labs/schema').SessionDetailHeaderPayload} SessionDetailHeaderPayload */
 /** Canonical schema values exposed for compatibility with existing consumers. @type {readonly Role[]} */
 export const ROLES: readonly Role[];
 /** @type {readonly EntryType[]} */
@@ -36,6 +42,12 @@ export type SessionScorecard = import("@peasant-labs/schema").SessionScorecard;
 export type CommitInfo = import("@peasant-labs/schema").CommitInfo;
 export type AnnotationSummary = import("@peasant-labs/schema").AnnotationSummary;
 export type SessionDetailPayload = import("@peasant-labs/schema").SessionDetailPayload;
+export type TranscriptSegmentDirectory = import("@peasant-labs/schema").TranscriptSegmentDirectory;
+export type TranscriptSegmentRef = import("@peasant-labs/schema").TranscriptSegmentRef;
+export type TranscriptSegment = import("@peasant-labs/schema").TranscriptSegment;
+export type TranscriptTurn = import("@peasant-labs/schema").TranscriptTurn;
+export type TranscriptWindow = import("@peasant-labs/schema").TranscriptWindow;
+export type SessionDetailHeaderPayload = import("@peasant-labs/schema").SessionDetailHeaderPayload;
 export type LegacyCommit = {
     hash: string;
     message: string;

package/dist/lib/types/ui/transcript/adapter.d.ts

@@ -20,6 +20,22 @@ export function thinkingDurationMs(previous: TurnDetail | undefined, turn: TurnD
  * @returns {TurnDetail[]}
  */
 export function prefilterTurns(turns: TurnDetail[]): TurnDetail[];
+/** @param {TurnVM[]} turnVMs @returns {FileEntryVM[]} */
+/**
+ * Aggregate the per-file read/edit/write counts and churn from cooked turns. Shared
+ * by the whole-transcript view model and a segmented viewer's loaded regions, so the
+ * Files tab has one derivation.
+ * @param {TurnVM[]} turnVMs
+ * @returns {FileEntryVM[]}
+ */
+export function buildFiles(turnVMs: TurnVM[]): FileEntryVM[];
+/**
+ * Tool-group counts for a set of cooked turns. Shared by the full filter index and a
+ * segmented viewer's loaded regions.
+ * @param {TurnVM[]} turnVMs
+ * @returns {Record<ToolGroup, number>}
+ */
+export function buildToolGroupCounts(turnVMs: TurnVM[]): Record<ToolGroup, number>;
 /**
  * Project the canonical wire payload (folded turns) into the cooked
  * `TranscriptViewModel` every dumb transcript component renders. The SOLE

package/dist/lib/types/ui/transcript/view-model.d.ts

@@ -397,6 +397,18 @@ export type TurnVM = {
      * annotations targeting this turn (may be empty)
      */
     annotations: AnnotationVM[];
+    /**
+     * the segment this turn arrived in, when read as part of loaded regions
+     */
+    segmentIndex?: number;
+    /**
+     * this turn's own text was bounded by the served-text bound
+     */
+    truncated?: boolean;
+    /**
+     * pre-bound JSON size of content + arguments + result; the truncation notice's size
+     */
+    byteLength?: number;
 };
 /**
  * A cooked annotation, already resolved to the turn it targets. The adapter maps

package/dist/lib/types/ui/transcript/wire-types.d.ts

@@ -11,6 +11,12 @@
 /** @typedef {import('@peasant-labs/schema').CommitInfo} CommitInfo */
 /** @typedef {import('@peasant-labs/schema').AnnotationSummary} AnnotationSummary */
 /** @typedef {import('@peasant-labs/schema').SessionDetailPayload} SessionDetailPayload */
+/** @typedef {import('@peasant-labs/schema').TranscriptSegmentDirectory} TranscriptSegmentDirectory */
+/** @typedef {import('@peasant-labs/schema').TranscriptSegmentRef} TranscriptSegmentRef */
+/** @typedef {import('@peasant-labs/schema').TranscriptSegment} TranscriptSegment */
+/** @typedef {import('@peasant-labs/schema').TranscriptTurn} TranscriptTurn */
+/** @typedef {import('@peasant-labs/schema').TranscriptWindow} TranscriptWindow */
+/** @typedef {import('@peasant-labs/schema').SessionDetailHeaderPayload} SessionDetailHeaderPayload */
 /** Canonical schema values exposed for compatibility with existing consumers. @type {readonly Role[]} */
 export const ROLES: readonly Role[];
 /** @type {readonly EntryType[]} */
@@ -36,6 +42,12 @@ export type SessionScorecard = import("@peasant-labs/schema").SessionScorecard;
 export type CommitInfo = import("@peasant-labs/schema").CommitInfo;
 export type AnnotationSummary = import("@peasant-labs/schema").AnnotationSummary;
 export type SessionDetailPayload = import("@peasant-labs/schema").SessionDetailPayload;
+export type TranscriptSegmentDirectory = import("@peasant-labs/schema").TranscriptSegmentDirectory;
+export type TranscriptSegmentRef = import("@peasant-labs/schema").TranscriptSegmentRef;
+export type TranscriptSegment = import("@peasant-labs/schema").TranscriptSegment;
+export type TranscriptTurn = import("@peasant-labs/schema").TranscriptTurn;
+export type TranscriptWindow = import("@peasant-labs/schema").TranscriptWindow;
+export type SessionDetailHeaderPayload = import("@peasant-labs/schema").SessionDetailHeaderPayload;
 export type LegacyCommit = {
     hash: string;
     message: string;