@monotykamary/dsh-client-ui-trajectory 0.1.0-rc.5

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Host loader entry for the browser-only trajectory plugin. */
+/** Provides no host-side behavior. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@monotykamary/dsh-client-ui-trajectory`.
+* @module @monotykamary/dsh-client-ui-trajectory/invariant
+*/
+const PACKAGE_NAME = "@monotykamary/dsh-client-ui-trajectory";
+/** Cordis companion plugin name. */
+const name = "client-ui-trajectory-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: a pure-consumer plugin — it emits no cordis events
+* and owns no mutable cross-plugin state; its view-slot registration is a
+* plain effect whose disposal the slot ledger's own specs and this
+* package's behavior specs observe directly.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/client/TrajectoryCell.d.ts

@@ -0,0 +1,10 @@
+import { formatElapsedSeconds, type TrajectoryCellProps } from './trajectory-record.ts';
+export { formatElapsedSeconds };
+export type { AssistantMetricDetail, TrajectoryCellKind, TrajectoryCellProps, } from './trajectory-record.ts';
+/**
+ * Render one trajectory step cell.
+ * @param props - index, kind, text, time, and optional Message metrics.
+ * @returns the cell element.
+ */
+export declare function TrajectoryCell({ index, kind, text, inputDetail: _inputDetail, promptDetail: _promptDetail, previousPromptDetail: _previousPromptDetail, outputDetail: _outputDetail, thinkingDetail: _thinkingDetail, sourceBlocks: _sourceBlocks, outputBlocks: _outputBlocks, schemaDetail: _schemaDetail, assistantMetrics: _assistantMetrics, result: _result, callId: _callId, isError: _isError, timeSeconds, startedAt: _startedAt, input, output, think, selected, className, ...rest }: TrajectoryCellProps): import("react").JSX.Element;
+//# sourceMappingURL=TrajectoryCell.d.ts.map

package/lib/types/client/TrajectoryGroupHeader.d.ts

@@ -0,0 +1,13 @@
+export interface TrajectoryGroupHeaderProps {
+    /** Group title (`Message`, `Step 1`, …). */
+    title: string;
+    /** Secondary summary (`49 s`, `2.2 s skill`, …). */
+    description?: string;
+}
+/**
+ * Render a Message/Step group header inside a turn body.
+ * @param props - title and optional description.
+ * @returns the group header element.
+ */
+export declare function TrajectoryGroupHeader({ title, description }: TrajectoryGroupHeaderProps): import("react").JSX.Element;
+//# sourceMappingURL=TrajectoryGroupHeader.d.ts.map

package/lib/types/client/TrajectoryTable.d.ts

@@ -0,0 +1,100 @@
+/** Turn-aware trajectory event ledger with a local record inspector. */
+import type { AssistantRequestConfig } from '@monotykamary/dsh-client-runtime/client';
+import type { TrajectoryCellProps } from './trajectory-record.ts';
+import type { TrajectoryTurnModel } from './layout.ts';
+/** Props for the trajectory ledger. */
+export interface TrajectoryTableProps {
+    /** Session-global request numbers for the request groups visible in this context. */
+    requestNumbers?: readonly TrajectoryRequestNumber[];
+    /** Grouped records in display order. */
+    turns: readonly TrajectoryTurnModel[];
+    /** In-flight cells whose content replaces the matching structural record index. */
+    streamingCells?: readonly TrajectoryCellProps[];
+    /** Record indexes emphasized by the active timeline focus. */
+    timelineFocusIndexes?: ReadonlySet<number> | null;
+    /** Record indexes retained by the active live search, or null without a query. */
+    searchMatchIndexes?: ReadonlySet<number> | null;
+    /** Report the record currently selected in the local inspector. */
+    onSelectedIndexChange?: (index: number | null) => void;
+    /** Report a direct user selection from a ledger row. */
+    onRecordSelect?: (index: number) => void;
+    /** One externally requested record selection; a new object repeats the request. */
+    recordSelection?: {
+        readonly index: number;
+    } | null;
+    /** One externally requested record focus without changing inspector selection. */
+    recordFocus?: {
+        readonly index: number;
+    } | null;
+    /** Whether the initial history tail is still loading. */
+    historyLoading?: boolean;
+    /** Whether one older history page request is pending anywhere. */
+    olderHistoryLoading?: boolean;
+    /** First loaded raw event, used to preserve scroll position after prepending a page. */
+    historyStartSeq?: number | undefined;
+    /** Whether one older history page can be requested. */
+    hasOlderRecords?: boolean;
+    /** Load one older history page. */
+    onLoadOlder?: () => Promise<boolean>;
+    /** Clear selection state owned by the ledger host. */
+    onClearSelection?: () => void;
+    /** Turn ids whose rows after the first are folded into a summary. */
+    collapsedTurns: ReadonlySet<number>;
+    /** Toggle one turn between folded and expanded. */
+    onToggleTurn: (turn: number) => void;
+    /** Stable Assistant record ids whose tool calls are folded. */
+    collapsedAssistants: ReadonlySet<string>;
+    /** Toggle tool calls under one assistant record. */
+    onToggleAssistant: (id: string) => void;
+    /** One-shot cross-view inspect: open and scroll to this call's record. */
+    inspectCallId?: string | null;
+    /** Acknowledge a consumed (or unresolvable) inspect request. */
+    onInspectApplied?: (() => void) | undefined;
+}
+/** Request-inspector fields shared by ordinary generation and compaction. */
+interface TrajectoryRequestNumberBase {
+    /** Request anchor event sequence; absent for the currently streaming ordinary request. */
+    seq?: number;
+    group: string;
+    number: number;
+    status?: 'complete' | 'running' | 'error';
+    startedAt?: number;
+    completedAt?: number | null;
+    error?: string;
+    retry?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    resultSeq?: number;
+    provider?: string;
+    model?: string;
+    requestConfig?: AssistantRequestConfig;
+    usage?: TrajectoryUsage;
+    cumulativeUsage?: TrajectoryUsage;
+}
+/** One purpose-discriminated request identity paired with its session-global number. */
+export type TrajectoryRequestNumber = TrajectoryRequestNumberBase & ({
+    purpose?: 'assistant';
+    turn: number;
+    step: number;
+} | {
+    purpose: 'compaction';
+    turn: number | null;
+    step: 0;
+});
+/** Disjoint provider token buckets for one request or a session prefix. */
+export interface TrajectoryUsage {
+    input?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    output?: number;
+    reasoning?: number;
+}
+/**
+ * Render trajectory events as a dense ledger with turn and step separators.
+ * Clicking ledger whitespace clears the active record or request selection.
+ * @param props - Grouped trajectory data and whole-ledger fold state.
+ * @returns The ledger and an optional local record inspector.
+ */
+export declare function TrajectoryTable({ requestNumbers: sessionRequestNumbers, turns, streamingCells, timelineFocusIndexes, searchMatchIndexes, onSelectedIndexChange, onRecordSelect, recordSelection, recordFocus, historyLoading, olderHistoryLoading, historyStartSeq, hasOlderRecords, onLoadOlder, onClearSelection, collapsedTurns, onToggleTurn, collapsedAssistants, onToggleAssistant, inspectCallId, onInspectApplied, }: TrajectoryTableProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=TrajectoryTable.d.ts.map

package/lib/types/client/TrajectoryTimeline.d.ts

@@ -0,0 +1,24 @@
+/** Chrome-Network-style overview timeline for focusing the trajectory ledger. */
+import type { TrajectoryTurnModel } from './layout.ts';
+import { type TrajectoryTimelineMode, type TrajectoryTimeRange } from './timeline.ts';
+/** Props for the fixed full-domain overview above the trajectory ledger. */
+export interface TrajectoryTimelineProps {
+    turns: readonly TrajectoryTurnModel[];
+    mode: TrajectoryTimelineMode;
+    range: TrajectoryTimeRange | null;
+    /** Whether the loaded timeline omits an earlier history prefix. */
+    hasEarlierRecords?: boolean;
+    /** Load one earlier history page from the truncation control. */
+    onLoadEarlier?: () => Promise<boolean>;
+    selectedIndex?: number | null;
+    /** Record indexes matching the active ledger search, or null without a query. */
+    searchMatchIndexes?: ReadonlySet<number> | null;
+    onRangeChange: (range: TrajectoryTimeRange | null) => void;
+    /** Select a directly clicked timeline block. */
+    onRecordSelect?: (index: number) => void;
+    /** Bring the nearest record into view after clicking timeline whitespace. */
+    onRecordFocus?: (index: number) => void;
+}
+/** Overview renderer with drag ranges, click-sized focus, and Escape reset. */
+export declare const TrajectoryTimeline: import("react").MemoExoticComponent<({ turns, mode, range, hasEarlierRecords, onLoadEarlier, selectedIndex, searchMatchIndexes, onRangeChange, onRecordSelect, onRecordFocus, }: TrajectoryTimelineProps) => import("react").JSX.Element>;
+//# sourceMappingURL=TrajectoryTimeline.d.ts.map

package/lib/types/client/TrajectoryToolbar.d.ts

@@ -0,0 +1,34 @@
+/** Trajectory toolbar: timeline and ledger fold controls. */
+import type { TranslateNS } from '@monotykamary/dsh-client-ui-slots';
+import type { NS } from './locales.ts';
+export interface TrajectoryToolbarProps {
+    /** Whether timeline blocks use recorded durations instead of equal widths. */
+    actualDuration: boolean;
+    /** Select recorded-duration or equal-width blocks. */
+    onActualDurationChange: (actualDuration: boolean) => void;
+    /** Whether recorded timing retains idle gaps between operations. */
+    actualTime: boolean;
+    /** Select complete wall-clock timing or idle-compressed timing. */
+    onActualTimeChange: (actualTime: boolean) => void;
+    /** Whether every collapsible turn is currently folded. */
+    allTurnsCollapsed: boolean;
+    /** Fold or expand every collapsible turn. */
+    onToggleAllTurns: () => void;
+    /** Whether every collapsible assistant's tool calls are currently folded. */
+    allAssistantsCollapsed: boolean;
+    /** Fold or expand tool calls under every collapsible assistant. */
+    onToggleAllAssistants: () => void;
+    /** Current live ledger search query. */
+    searchQuery: string;
+    /** Update the live ledger search query. */
+    onSearchQueryChange: (query: string) => void;
+    /** Translate a toolbar dictionary key. */
+    t: TranslateNS<typeof NS>;
+}
+/**
+ * Render the sticky trajectory toolbar.
+ * @param props - rendered counts and whole-list fold state.
+ * @returns the toolbar element.
+ */
+export declare function TrajectoryToolbar({ actualDuration, onActualDurationChange, actualTime, onActualTimeChange, allTurnsCollapsed, onToggleAllTurns, allAssistantsCollapsed, onToggleAllAssistants, searchQuery, onSearchQueryChange, t, }: TrajectoryToolbarProps): import("react").JSX.Element;
+//# sourceMappingURL=TrajectoryToolbar.d.ts.map

package/lib/types/client/TrajectoryTurn.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+export interface TrajectoryTurnProps {
+    /** 1-based turn index for the sticky header. */
+    turn: number;
+    /** Message / Step headers and TrajectoryCell rows. */
+    children?: ReactNode;
+}
+/**
+ * Render one turn section (sticky header + body).
+ * @param props - turn index and body children.
+ * @returns the turn section element.
+ */
+export declare function TrajectoryTurn({ turn, children }: TrajectoryTurnProps): import("react").JSX.Element;
+//# sourceMappingURL=TrajectoryTurn.d.ts.map

package/lib/types/client/TrajectoryTurnHeader.d.ts

@@ -0,0 +1,11 @@
+export interface TrajectoryTurnHeaderProps {
+    /** 1-based turn index shown as `Turn N`. */
+    turn: number;
+}
+/**
+ * Render the sticky turn header row.
+ * @param props.turn - turn index.
+ * @returns the sticky header element.
+ */
+export declare function TrajectoryTurnHeader({ turn }: TrajectoryTurnHeaderProps): import("react").JSX.Element;
+//# sourceMappingURL=TrajectoryTurnHeader.d.ts.map

package/lib/types/client/TrajectoryView.d.ts

@@ -0,0 +1,14 @@
+/** Trajectory view: compact summary over a turn-aware event ledger. */
+import type { ConvViewProps } from '@monotykamary/dsh-client-ui-conversation/client';
+import type { InjectFace, PropsLocale } from '@monotykamary/dsh-client-ui-slots';
+import type { SnapshotStore } from '@monotykamary/dsh-client-runtime/client';
+/** Session-bound controls not already supplied by the conversation view slot. */
+export interface TrajectoryViewInjected {
+    hooks: {
+        duration: SnapshotStore<boolean>;
+    };
+    loadOlder: () => Promise<boolean>;
+    setActualDuration: (actualDuration: boolean) => void;
+}
+export declare function TrajectoryView({ useSession, useDuration, loadOlder, setActualDuration, inspect, onInspectDone, t, }: ConvViewProps & InjectFace<TrajectoryViewInjected> & PropsLocale<'trajectory'>): import("react").JSX.Element;
+//# sourceMappingURL=TrajectoryView.d.ts.map

package/lib/types/client/duration-store.d.ts

@@ -0,0 +1,7 @@
+import { type SnapshotStore } from '@monotykamary/dsh-client-runtime/client';
+/**
+ * Create the browser-wide trajectory duration preference source.
+ * @returns a persisted source shared by every session view in one plugin lifecycle.
+ */
+export declare function createTrajectoryDurationStore(): SnapshotStore<boolean>;
+//# sourceMappingURL=duration-store.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * Browser trajectory plugin contributing one entry to the conversation view
+ * slot without defining a service.
+ */
+import type { Context } from '@monotykamary/cordis';
+/** Required services: the conversation slot, registries, ordinary Session paging, and the locale service. */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the trajectory view tab. The registration
+ * rides the slot service's effect wrapper, so plugin unload removes the tab.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/layout.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Trajectory list fold: expand assistant blocks, attach usage to Message,
+ * own-duration times, in-flight partial/runningCalls, and group descriptions.
+ */
+import type { ConversationLocation, ConversationSnapshot, RequestInspectionSnapshot, RequestView } from '@monotykamary/dsh-client-runtime/client';
+import type { TrajectoryCellProps } from './trajectory-record.ts';
+/** One Message or Step group inside a turn. */
+export interface TrajectoryGroupModel {
+    title: string;
+    description?: string;
+    cells: readonly TrajectoryCellProps[];
+}
+/** One sticky turn, or a standalone compaction section between turns. */
+export interface TrajectoryTurnModel {
+    turn: number | null;
+    groups: readonly TrajectoryGroupModel[];
+}
+/** Snapshot slice the trajectory view folds. */
+export interface TrajectoryLayoutInput {
+    nodes: ConversationSnapshot['nodes'];
+    eventLocations?: ReadonlyMap<number, ConversationLocation>;
+    partial: ConversationSnapshot['partial'];
+    runningCalls: ConversationSnapshot['runningCalls'];
+    requests?: readonly RequestView[];
+    callSchemas?: RequestInspectionSnapshot['callSchemas'];
+}
+/**
+ * Fold a snapshot into turn → Message/Step groups with expanded cells.
+ * @param input - nodes plus in-flight partial/runningCalls.
+ * @returns turns ordered by first appearance.
+ */
+export declare function deriveTrajectoryLayout(input: TrajectoryLayoutInput): readonly TrajectoryTurnModel[];
+/**
+ * Append the changing in-flight assistant cells to a stable finalized layout.
+ * @param turns - Finalized layout derived with an empty-block partial anchor.
+ * @param partial - Current in-flight assistant projection.
+ * @param lastIndex - Highest cell index in the finalized layout.
+ * @returns The original layout without a partial, otherwise a layout sharing every unaffected turn.
+ */
+export declare function appendTrajectoryPartialLayout(turns: readonly TrajectoryTurnModel[], partial: ConversationSnapshot['partial'], lastIndex: number): readonly TrajectoryTurnModel[];
+//# sourceMappingURL=layout.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,16 @@
+/** `trajectory` namespace dictionaries (view tab label + toolbar strings). */
+/** Dictionary namespace owned by this plugin. */
+export declare const NS = "trajectory";
+/** The trajectory dictionary key set (the source of truth for both locales). */
+export type TrajectoryKey = 'view.trajectory' | 'toolbar.aria' | 'toolbar.duration' | 'toolbar.useActualDuration' | 'toolbar.useEqualWidth' | 'toolbar.actualTime' | 'toolbar.turns' | 'toolbar.expandTurns' | 'toolbar.collapseTurns' | 'toolbar.calls' | 'toolbar.expandCalls' | 'toolbar.collapseCalls' | 'toolbar.search' | 'toolbar.searchPlaceholder';
+declare module '@monotykamary/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The trajectory view tab label and toolbar strings. */
+        'trajectory': TrajectoryKey;
+    }
+}
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: Record<TrajectoryKey, string>;
+/** English dictionary. */
+export declare const en: Record<TrajectoryKey, string>;
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/timeline.d.ts

@@ -0,0 +1,50 @@
+/** Operation-sequence and recorded-time projections for the trajectory overview. */
+import type { TrajectoryTurnModel } from './layout.ts';
+import type { TrajectoryCellKind } from './trajectory-record.ts';
+/** Horizontal projection used by the trajectory timeline. */
+export type TrajectoryTimelineMode = 'sequence' | 'duration' | 'time' | 'actual';
+/** Inclusive selection in the active timeline projection's domain. */
+export interface TrajectoryTimeRange {
+    start: number;
+    end: number;
+}
+/** One ledger record projected into the active timeline domain. */
+export interface TrajectoryTimelineSpan extends TrajectoryTimeRange {
+    index: number;
+    isError: boolean;
+    kind: TrajectoryCellKind;
+    label: string;
+    lane: number;
+}
+/** One turn boundary in the active timeline domain. */
+export interface TrajectoryTimelineTurnBoundary {
+    turn: number;
+    time: number;
+}
+/** Full-domain model used by the overview. */
+export interface TrajectoryTimelineModel extends TrajectoryTimeRange {
+    spans: readonly TrajectoryTimelineSpan[];
+    turnBoundaries: readonly TrajectoryTimelineTurnBoundary[];
+}
+/**
+ * Format a timeline duration as an integer-millisecond label.
+ * @param milliseconds - Non-negative duration in milliseconds.
+ * @returns Millisecond label with thousands separators.
+ */
+export declare function formatTimelineOffset(milliseconds: number): string;
+/**
+ * Project every visible record into a stable three-lane timeline.
+ * @param turns - Unfiltered trajectory layout.
+ * @param mode - Independent equal/recorded duration and compressed/complete time projection.
+ * @returns Timeline model, or `null` when no record is visible.
+ */
+export declare function deriveTrajectoryTimeline(turns: readonly TrajectoryTurnModel[], mode?: TrajectoryTimelineMode): TrajectoryTimelineModel | null;
+/**
+ * Identify records active at any point inside an inclusive selected interval.
+ * @param turns - Unfiltered trajectory layout.
+ * @param range - Selected interval in the active projection.
+ * @param mode - Independent equal/recorded duration and compressed/complete time projection.
+ * @returns Record indexes inside the focus interval.
+ */
+export declare function trajectoryTimelineFocusIndexes(turns: readonly TrajectoryTurnModel[], range: TrajectoryTimeRange, mode?: TrajectoryTimelineMode): ReadonlySet<number>;
+//# sourceMappingURL=timeline.d.ts.map

package/lib/types/client/trajectory-assistant-definition.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@monotykamary/cordis';
+/**
+ * Register the Trajectory Assistant lifecycle.
+ *
+ * @param ctx - Plugin context receiving the Definitions.
+ */
+export declare function registerTrajectoryAssistantDefinition(ctx: Context): void;
+//# sourceMappingURL=trajectory-assistant-definition.d.ts.map

package/lib/types/client/trajectory-compaction-definition.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@monotykamary/cordis';
+/**
+ * Register Trajectory compaction requests and session boundaries.
+ *
+ * @param ctx - Plugin context receiving the Definitions.
+ */
+export declare function registerTrajectoryCompactionDefinitions(ctx: Context): void;
+//# sourceMappingURL=trajectory-compaction-definition.d.ts.map

package/lib/types/client/trajectory-contract.d.ts

@@ -0,0 +1,64 @@
+import type { AssistantMessageNode, ConversationLocation, ConversationNode, ConversationPromptSnapshot, ConversationViewNode, PartialAssistant, RequestPromptChange, RequestView, RunningToolCall, ToolCallBlock } from '@monotykamary/dsh-client-runtime/client';
+/** Request-header facts retained by the Trajectory target. */
+export interface TrajectoryRequestHeaderState {
+    readonly seq: number;
+    readonly time: number;
+    readonly prompt: ConversationPromptSnapshot;
+    readonly change?: RequestPromptChange;
+    readonly location: ConversationLocation;
+}
+/** One independently assembled contribution to the legacy Trajectory ledger. */
+export type TrajectoryContribution = {
+    readonly kind: 'node';
+    readonly node: ConversationNode;
+} | {
+    readonly kind: 'assistant';
+    readonly node?: AssistantMessageNode;
+    readonly partial: PartialAssistant | null;
+    readonly request?: Extract<RequestView, {
+        purpose: 'assistant';
+    }>;
+} | {
+    readonly kind: 'tool';
+    readonly root: ToolCallBlock;
+} | {
+    readonly kind: 'request-header';
+    readonly header: TrajectoryRequestHeaderState;
+} | {
+    readonly kind: 'compaction';
+    readonly request: Extract<RequestView, {
+        purpose: 'compaction';
+    }>;
+} | {
+    readonly kind: 'session-end';
+    readonly seq: number;
+    readonly time: number;
+} | {
+    readonly kind: 'turn-end';
+    readonly turn: number;
+    readonly time: number;
+    readonly error?: string;
+};
+/** Target envelope consumed by the Trajectory snapshot builder. */
+export interface TrajectoryConversationViewNode extends ConversationViewNode {
+    readonly target: 'trajectory';
+    readonly anchorSeq: number;
+    readonly location: ConversationLocation;
+    readonly data: TrajectoryContribution;
+}
+/** Stage-oriented Trajectory data assembled from registered business Contexts. */
+export interface TrajectorySnapshot {
+    readonly eventNodes: readonly ConversationNode[];
+    readonly eventLocations: ReadonlyMap<number, ConversationLocation>;
+    readonly requests: readonly RequestView[];
+    readonly callSchemas: ReadonlyMap<string, ConversationPromptSnapshot['tools'][number]>;
+    readonly partial: PartialAssistant | null;
+    readonly runningCalls: readonly RunningToolCall[];
+}
+declare module '@monotykamary/dsh-client-runtime/client' {
+    interface ConversationViewSnapshotMap {
+        /** Independently assembled data consumed by the Trajectory view. */
+        trajectory: TrajectorySnapshot;
+    }
+}
+//# sourceMappingURL=trajectory-contract.d.ts.map

package/lib/types/client/trajectory-definition-common.d.ts

@@ -0,0 +1,12 @@
+import type { ConversationNodeContext } from '@monotykamary/dsh-client-runtime/client';
+import type { TrajectoryContribution, TrajectoryConversationViewNode } from './trajectory-contract.ts';
+/**
+ * Wrap one contribution in the Engine-owned target envelope.
+ *
+ * @param context - Context that owns the contribution identity.
+ * @param anchorSeq - Sequence used to order the contribution.
+ * @param data - Trajectory-specific contribution payload.
+ * @returns The contribution wrapped as a Trajectory view node.
+ */
+export declare function trajectoryNode(context: ConversationNodeContext, anchorSeq: number, data: TrajectoryContribution): TrajectoryConversationViewNode;
+//# sourceMappingURL=trajectory-definition-common.d.ts.map

package/lib/types/client/trajectory-message-definitions.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@monotykamary/cordis';
+/**
+ * Register Trajectory-owned inbox classification and message records.
+ *
+ * @param ctx - Plugin context receiving the Definitions.
+ */
+export declare function registerTrajectoryMessageDefinitions(ctx: Context): void;
+//# sourceMappingURL=trajectory-message-definitions.d.ts.map

package/lib/types/client/trajectory-preview.d.ts

@@ -0,0 +1,8 @@
+/** Bounded Markdown-to-text projection shared by trajectory consumers. */
+/**
+ * Build a bounded one-line preview without parsing the complete Markdown document.
+ * @param text - Untrusted message, reasoning, payload, or result text.
+ * @returns A compact preview capped independently from the retained source.
+ */
+export declare function trajectoryPreviewText(text: string): string;
+//# sourceMappingURL=trajectory-preview.d.ts.map

package/lib/types/client/trajectory-record.d.ts

@@ -0,0 +1,105 @@
+/** Shared trajectory record data and formatting contracts. */
+import type { HTMLAttributes } from 'react';
+import type { ConversationPromptSnapshot } from '@monotykamary/dsh-client-runtime/client';
+/** Closed set of trajectory record kinds. */
+export type TrajectoryCellKind = 'system' | 'user' | 'context' | 'compacted' | 'message' | 'tool' | 'subtool';
+/** Recorded inputs needed to derive assistant TTFT and decode throughput. */
+export interface AssistantMetricDetail {
+    timingRecorded: boolean;
+    stepStartTime: number | null;
+    firstTokenTime: number | null;
+    completedTime: number | null;
+    usageProvided: boolean;
+    outputTokens: number | null;
+}
+/** One source content block preserved in model order for the details panel. */
+export interface TrajectorySourceBlock {
+    type: string;
+    content: string;
+    imageSrc?: string;
+    imageAlt?: string;
+    callId?: string;
+    toolName?: string;
+}
+/** Data and optional presentation attributes for one trajectory record. */
+export interface TrajectoryCellProps extends HTMLAttributes<HTMLDivElement> {
+    /** 1-based record index shown as `#N`. */
+    index: number;
+    /** Projection-stable identity when no single source event owns the record lifecycle. */
+    recordId?: string;
+    kind: TrajectoryCellKind;
+    /** Non-Markdown summary or prefix; CSS ellipsis when it overflows. */
+    text: string;
+    /** Raw Markdown source converted into the single-line summary at its consumer. */
+    previewMarkdown?: string;
+    /** Whether this user record opens a new model turn. */
+    opensTurn?: boolean;
+    /** Source session-event seq for cross-record navigation. */
+    sourceSeq?: number;
+    /** Producer role and name from a user-role message or context injection. */
+    messageSource?: unknown;
+    /** Producer-owned model-hidden metadata carried beside the message source. */
+    /** A separator-only anchor for an auxiliary request with no visible record. */
+    requestOnly?: boolean;
+    /** Full request/message content for the details panel. */
+    inputDetail?: string;
+    /** Complete system-prompt/tool-catalog state introduced by a SYSTEM record. */
+    promptDetail?: ConversationPromptSnapshot;
+    /** System-prompt/tool-catalog state replaced by a SYSTEM update. */
+    previousPromptDetail?: ConversationPromptSnapshot;
+    /** Full assistant/tool result content for the details panel. */
+    outputDetail?: string;
+    /** Full assistant reasoning content for the details panel. */
+    thinkingDetail?: string;
+    /** Original message blocks in source order for the details panel. */
+    sourceBlocks?: readonly TrajectorySourceBlock[];
+    /** Original tool result blocks in source order for the details panel. */
+    outputBlocks?: readonly TrajectorySourceBlock[];
+    /** Call-time model-visible tool schema for the details panel. */
+    schemaDetail?: string;
+    /** Assistant-only timing and token facts for the details panel. */
+    assistantMetrics?: AssistantMetricDetail;
+    /** Tool-only result summary paired with the call in the same record. */
+    result?: string;
+    /** Raw Markdown source converted into the tool-result summary at its consumer. */
+    resultPreviewMarkdown?: string;
+    /** Tool call id used to link message source blocks to tool records. */
+    callId?: string;
+    /** Tool-only result failure state. */
+    isError?: boolean;
+    /** Own duration in seconds, or `null` when no duration is known. */
+    timeSeconds: number | null;
+    /** Unix epoch milliseconds when this operation actually started, when known. */
+    startedAt?: number | null;
+    /** Message-only prompt token count. */
+    input?: number;
+    /** Message-only input tokens served from a provider cache. */
+    cacheRead?: number;
+    /** Message-only input tokens written into a provider cache. */
+    cacheWrite?: number;
+    /** Message-only completion token count. */
+    output?: number;
+    /** Message-only reasoning token count. */
+    think?: number;
+    /** Whether the legacy standalone cell renders its selection treatment. */
+    selected?: boolean;
+}
+/**
+ * Resolve the identity that survives prepending older projected records.
+ * @param cell - Projected trajectory record.
+ * @returns Stable identity from the owning event or tool call, with a fixture fallback.
+ */
+export declare function trajectoryRecordId(cell: TrajectoryCellProps): string;
+/**
+ * Format a duration in milliseconds with thousands separators.
+ * @param milliseconds - Duration in milliseconds, or `null` when absent.
+ * @returns `—` when unknown, otherwise an integer-millisecond label.
+ */
+export declare function formatDurationMillis(milliseconds: number | null): string;
+/**
+ * Format an elapsed duration given in seconds as a millisecond label.
+ * @param seconds - Duration seconds, or `null` when absent.
+ * @returns `—` when unknown, otherwise an integer-millisecond label.
+ */
+export declare function formatElapsedSeconds(seconds: number | null): string;
+//# sourceMappingURL=trajectory-record.d.ts.map

package/lib/types/client/trajectory-request-header-definition.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@monotykamary/cordis';
+/**
+ * Register Trajectory request-header facts.
+ *
+ * @param ctx - Plugin context receiving the Definition.
+ */
+export declare function registerTrajectoryRequestHeaderDefinition(ctx: Context): void;
+//# sourceMappingURL=trajectory-request-header-definition.d.ts.map