@peasant-labs/fairtrade 0.0.61 → 0.0.63

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;