@peasant-labs/fairtrade 0.0.15 → 0.0.17

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

@@ -1,13 +1,15 @@
 /**
  * @param {object} props
  * @param {boolean} [props.checked]
+ * @param {boolean} [props.indeterminate]  render the tri-state 'mixed' box (some children on)
  * @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 }: {
+export default function CheckRow({ checked, indeterminate, onChange, children, count, disabled }: {
     checked?: boolean;
+    indeterminate?: boolean;
     onChange?: Function;
     children?: any;
     count?: number;

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

@@ -0,0 +1,127 @@
+/** @typedef {import('./view-model.js').TurnVM} TurnVM */
+/** @typedef {import('./view-model.js').ToolGroup} ToolGroup */
+/** @typedef {import('./state-capabilities.js').TranscriptFilters} TranscriptFilters */
+/** @typedef {'prompts' | 'responses' | 'thinking' | 'toolcalls'} Category */
+/**
+ * Every part kind a cooked turn carries, in rail order. Empty for turns no
+ * category governs (system notices). A turn with text and tool calls reports
+ * both; the rail badges count turns per kind from this.
+ *
+ * @param {TurnVM} turn
+ * @returns {Category[]}
+ */
+export function kindsOf(turn: TurnVM): Category[];
+/**
+ * Semantic tags NARROW: with none checked every turn passes; with one or more
+ * checked a turn must carry at least one of them. `annotationsByTurn` is the
+ * adapter's index (`vm.filterIndex.annotationsByTurn`).
+ *
+ * @param {TurnVM} turn
+ * @param {{ errors?: boolean, retries?: boolean, revert?: boolean }} tags
+ * @param {Record<number, {kind?: string}[]>} annotationsByTurn
+ */
+export function passesTags(turn: TurnVM, tags: {
+    errors?: boolean;
+    retries?: boolean;
+    revert?: boolean;
+}, annotationsByTurn: Record<number, {
+    kind?: string;
+}[]>): boolean;
+/**
+ * The per-turn projection: the turn with every hidden part removed, or `null`
+ * when nothing would be left to render. Tags narrow at the turn level, the
+ * checkpoint anchor scopes to a prefix, and then each part is kept or dropped
+ * by its own category (tool calls also by their group). System turns carry no
+ * governed parts and pass the category stage untouched.
+ *
+ * The returned object keeps `index`, `role`, labels and annotations, so
+ * anchors, jumps and the outline resolve against it exactly as against the
+ * original; only `content`, `thinking` and `toolCalls` change.
+ *
+ * @param {TurnVM} turn
+ * @param {TranscriptFilters} filters
+ * @param {object} [ctx]
+ * @param {Record<number, {kind?: string}[]>} [ctx.annotationsByTurn]
+ * @param {number | null} [ctx.checkpointTurn]  inclusive upper turn index, or null
+ * @returns {TurnVM | null}
+ */
+export function projectTurn(turn: TurnVM, filters: TranscriptFilters, ctx?: {
+    annotationsByTurn?: Record<number, {
+        kind?: string;
+    }[]>;
+    checkpointTurn?: number | null;
+}): TurnVM | null;
+/**
+ * Whether any part of the turn survives the filters. Equivalent to
+ * `projectTurn(...) !== null`; kept as the yes/no form for callers that only
+ * need membership.
+ *
+ * @param {TurnVM} turn
+ * @param {TranscriptFilters} filters
+ * @param {Parameters<typeof projectTurn>[2]} [ctx]
+ * @returns {boolean}
+ */
+export function matchesFilters(turn: TurnVM, filters: TranscriptFilters, ctx?: Parameters<typeof projectTurn>[2]): boolean;
+/**
+ * Turn-based category counts for the rail badges: each badge counts the turns
+ * that carry its part kind. A turn with text and tool calls is counted under
+ * both, so the badges can sum to more than the turn count; each promises
+ * "this many turns contain this".
+ * (The previous `toolcalls` badge counted tool CALLS, which only coincidentally
+ * matches the turn count when every turn carries exactly one.)
+ *
+ * @param {TurnVM[]} turns
+ * @returns {Record<Category, number>}
+ */
+export function categoryCounts(turns: TurnVM[]): Record<Category, number>;
+/**
+ * Tri-state for the `tool calls` umbrella: `true` when every group with matches
+ * is on, `false` when all are off, `'mixed'` otherwise. Groups with a zero count
+ * are IGNORED — the rail disables them, so a permanently-unreachable group must
+ * not hold the umbrella in a mixed state the user cannot resolve.
+ *
+ * @param {Partial<Record<ToolGroup, boolean>>} toolGroups
+ * @param {Partial<Record<ToolGroup, number>>} [counts]
+ * @returns {true | false | 'mixed'}
+ */
+export function toolGroupsState(toolGroups: Partial<Record<ToolGroup, boolean>>, counts?: Partial<Record<ToolGroup, number>>): true | false | "mixed";
+/**
+ * The umbrella cascade: setting `tool calls` writes every selectable group to
+ * match. Groups with no matches are written too, so re-checking the umbrella
+ * cannot leave a hidden `false` behind that would suppress a group the moment a
+ * different session gives it matches.
+ *
+ * @param {boolean} next
+ * @returns {Record<ToolGroup, boolean>}
+ */
+export function cascadeToolGroups(next: boolean): Record<ToolGroup, boolean>;
+/**
+ * Toggling ONE group re-derives the umbrella, so the pair is never contradictory
+ * (all seven off while `tool calls` still reads checked). Unchecking the last
+ * live group turns the umbrella off; checking any group turns it back on.
+ *
+ * A state whose umbrella is already off is normalised first: every group is
+ * treated as off, whatever the map says. That covers filter state persisted by
+ * a consumer before the cascade existed (`toolcalls: false` over an all-true
+ * map), where the rail shows every child unchecked and the user's click on ONE
+ * child must enable that one, not the other six.
+ *
+ * @param {TranscriptFilters} filters
+ * @param {ToolGroup} id
+ * @param {Partial<Record<ToolGroup, number>>} [counts]
+ * @returns {TranscriptFilters}
+ */
+export function toggleToolGroup(filters: TranscriptFilters, id: ToolGroup, counts?: Partial<Record<ToolGroup, number>>): TranscriptFilters;
+/**
+ * Setting the umbrella cascades to the groups in the same update, so the rail
+ * never renders a checked child under an unchecked parent.
+ *
+ * @param {TranscriptFilters} filters
+ * @param {boolean} next
+ * @returns {TranscriptFilters}
+ */
+export function setToolCalls(filters: TranscriptFilters, next: boolean): TranscriptFilters;
+export type TurnVM = import("./view-model.js").TurnVM;
+export type ToolGroup = import("./view-model.js").ToolGroup;
+export type TranscriptFilters = import("./state-capabilities.js").TranscriptFilters;
+export type Category = "prompts" | "responses" | "thinking" | "toolcalls";