@theoremjs/studio 0.3.4-next.482.g7e608f2 → 0.3.4-next.508.geda6db0

package/ui/lib/tree-map-layout.d.ts

@@ -12,8 +12,21 @@ export declare const INDENT = 28;
 /** A token's half height. */
 export declare const HALF = 11;
 export declare const PAD = 16;
-export declare const RUNNER = "runner";
-export declare const TOOL_RUNNER = "tool-runner";
+/** Grown, the room over the columns their headings take: a title, the line under it, and a gap. */
+export declare const HEADING = 56;
+/** Grown, each column's heading, in order: the tree, the registries, the runner. */
+export declare const HEADINGS: readonly {
+    label: string;
+    note: string;
+}[];
+/** What the still shows and growing takes away is gone by this far grown. */
+export declare const LEAVE_TO = 0.2;
+export declare const TOOL_RUNTIME = "tool-runtime";
+export declare const GUARDRAIL_RUNTIME = "guardrail-runtime";
+export declare const TRACE_DESTINATIONS = "trace-destinations";
+export declare const PROVIDER_STREAM = "provider-stream";
+export declare const KEY_VAULT = "key-vault";
+export declare const TURN_LOOP = "turn-loop";
 export interface Place {
     x: number;
     y: number;
@@ -24,38 +37,43 @@ export interface Row extends Place {
     /** The row above it in the tree, by its token id. */
     parent?: string;
 }
-export type FeedKind = 'runner' | 'step' | 'provider' | 'protocol' | 'tool' | 'branch' | 'subagent' | 'tool-runner' | 'check';
-/** What feeds the tree: a runner, a provider, a tool, or one of their own nested under them. */
+export type FeedKind = 'step' | 'provider' | 'protocol' | 'tool' | 'branch' | 'subagent' | 'tool-runtime' | 'guardrail-runtime' | 'check' | 'destinations' | 'vault' | 'stream' | 'model';
+/** What feeds the tree: a tool, the runner, a provider, the tool runner, or one of their own nested under them. */
 export interface Feed {
     id: string;
     label: string;
     kind: FeedKind;
     /** A tool's type, a subagent's profile type, or a step's or a check's id: what its icon is. */
     of?: string;
-    /** The tree rows it has a line into. */
-    into: string[];
+    /** What it has a line from: tree rows, and feeds in a column left of it. */
+    from: string[];
+    /** Tree rows it has a line from that draw in with the first feed under it. */
+    late?: string[];
     /** The feed it is one of, a level in under it. */
     under?: string;
-    /** Another feed it has a line to: a subagent to the runner that runs it, the tool loop to the tool runner. */
-    joins?: string;
-    /** The column it stands in beside the tree, first or second. */
+    /** The column it stands in beside the tree: the registries, or the runner. */
     column: 1 | 2;
     /** Feeds that stand together, with a gap before the next group. */
     group: string;
 }
 /**
  * What the runner does in a turn, in order: the steps of the kernel contract's turn lifecycle
- * (docs/contracts/kernel.md, "Turn lifecycle") that do work.
+ * (docs/contracts/kernel.md, "Turn lifecycle") that do work, and the profile sections each reads.
  * why: The canary bind runs only while a canary detector is on, and pre_turn, before_end and
- * post_turn are hooks for the host's stages, so the map leaves those four out.
+ * post_turn are hooks for the host's stages, so the map leaves those four out; the structured
+ * reply's validation is the outputs' own, not a story of the runner's, so it is left out too.
+ * Sanitize and egress are named for what they guard, the input and the reply, and drawn from them.
  */
 export declare const TURN_STEPS: readonly {
     id: string;
     label: string;
+    reads: readonly string[];
 }[];
 /**
- * What the tool runner checks of every call, in order (`executeRegisteredTool`): its permission,
- * its sign-in, the network a remote call reaches, and the guard on its result.
+ * What the tool runner does with every call (`executeRegisteredTool`): its permission, the MCP
+ * session an MCP call runs in, and its sign-in.
+ * why: The sessions stand before the sign-in, level with the third tool, so an MCP tool there has a
+ * straight line to them.
  */
 export declare const TOOL_CHECKS: readonly {
     id: string;
@@ -63,6 +81,14 @@ export declare const TOOL_CHECKS: readonly {
 }[];
 /** A row's token id: the tree's ids repeat from one agent to the next. */
 export declare function rowId(row: Row): string;
+/** Slow out, slow in: how far a move or a draw has gone at `at` of its time, both from 0 to 1. */
+/** A gentle ease in and out, for what moves far: it never rushes through the middle. */
+export declare const soft: (at: number) => number;
+/** An ease that comes in quickly and settles slowly, for what drifts the last of its way. */
+export declare const settling: (at: number) => number;
+/** How far the map's frame has settled this far grown, 0 to 1: its size and place, and what holds it. */
+export declare const settledAt: (grow: number) => number;
+export declare const ease: (at: number) => number;
 /** Where a node under a feed sits from it: across, and rows down. */
 export interface Slot {
     holder: string;
@@ -84,16 +110,92 @@ export interface TreeMapLayout {
     grown: Map<string, Place>;
     /** A row's height grown. */
     row: number;
+    /** Grown, each column's heading: its top left corner. */
+    headings: ({
+        label: string;
+        note: string;
+    } & Place)[];
     slots: Map<string, Slot>;
-    /** When each node growing adds starts to draw. */
-    starts: Map<string, number>;
+    /** How far grown the drawing reaches each node, by its id. */
+    reach: Map<string, number>;
+    /** What the drawing reaches each node from, by its id. */
+    reachedFrom: Map<string, string>;
+    /** How far grown each node's lines leave it, by its id: once it stands shown and still. */
+    leaves: Map<string, number>;
+    /** How far grown each node of the still starts its glide into place, by its id. */
+    gathers: Map<string, number>;
+    /** How far grown each node of the still that makes room lands, by its id: as its line reaches it. */
+    lands: Map<string, number>;
+    /** How much of the growing the drawing takes over one pixel of line. */
+    pace: number;
+    /** The lines the still draws closed, by their keys. */
+    drawnClosed: Set<string>;
+    /** What each node growing adds grows from, by its id: it draws in after it, and keeps to it. */
+    anchors: Map<string, string>;
+    /** Grown, where the lines into each feed run down to it. */
+    lanes: Map<string, Lane>;
+    /** Grown, where a line steps aside to pass between rows, by its key. */
+    jogs: Map<string, Jog[]>;
+    /** What the still shows that growing takes away: its rows, its feeds, and its lines. */
+    leaving: {
+        rows: Row[];
+        feeds: Feed[];
+        lines: {
+            source: string;
+            feed: string;
+        }[];
+    };
+    /** A row of the still that growing turns into a feed, by its id: the feed's id. */
+    becomes: Map<string, string>;
+    /** Closed, where the lines from each row run down to what it shows, by the row's id. */
+    trunks: Map<string, number>;
+}
+/** How far what the still shows and growing takes away has gone, 0 to 1. */
+export declare function goneAt(grow: number): number;
+/** The key under which the line into a feed under another draws, for a feed that was a row. */
+export declare const underKey: (feed: string) => string;
+/** A feed's lane: `by` left of the column it stands in, which starts at the feed `of`. */
+export interface Lane {
+    of: string;
+    by: number;
 }
-/** Where a node stands this far grown: a node under a feed keeps its slot under it on the way. */
+/**
+ * Where a node stands this far grown. A node of the still glides to where it stands grown in one
+ * eased move, landing as the drawing reaches it. A node growing adds stands where it stands from
+ * the node it grows from, and moves with it, drifting in along its line as it shows.
+ */
 export declare function placeAt(layout: TreeMapLayout, id: string, grow: number): Place;
-/** How far a node growing adds has drawn, 0 to 1; undefined for one the map shows closed. */
+/**
+ * Whether a node stands still this far grown: closed, what the still shows; then each node once it
+ * is out and in its zone, and what it comes out from too. What growing takes away is on its way.
+ */
+export declare function atRest(layout: TreeMapLayout, id: string, grow: number): boolean;
+/**
+ * How far a node growing adds has shown, 0 to 1, once the drawing has reached it; undefined for
+ * what the map shows closed.
+ */
 export declare function drawnAt(layout: TreeMapLayout, id: string, grow: number): number | undefined;
+/**
+ * How far the line from `source` to `target` has drawn, 0 to 1: it runs out from its source at the
+ * drawing's pace once its source stands shown and still, easing out of it and into its end. What the still draws closed is drawn.
+ */
+export declare function lineAt(layout: TreeMapLayout, source: string, target: string, grow: number): number;
+/** A line's step aside: in the gap at `lane`, to half a row above (-1) or below (1) `near`. */
+export interface Jog {
+    lane: Lane;
+    near: string;
+    side: 1 | -1;
+}
+/** Whether `source` stands in `feed`'s own column: its line runs out to the right of the column and back. */
+export declare function beside(layout: TreeMapLayout, source: string, feed: Feed): boolean;
+/** The key of the line from `source` into `feed`. */
+export declare const lineKey: (source: string, feed: string) => string;
 /**
  * The tree and what feeds it, closed and grown, for tokens this wide: grown, it fills `box` when
  * one is given.
  */
-export declare function treeMapLayout(workspace: StudioWorkspace, agents: readonly string[] | undefined, width: (id: string) => number, box?: Box): TreeMapLayout;
+export declare function treeMapLayout(workspace: StudioWorkspace, agents: readonly string[] | undefined, width: (id: string) => number, box?: Box, 
+/** The agents the map shows closed, when not the tree's. */
+still?: readonly string[], 
+/** Where the tokens the map shows closed stand, by id, when not where the still puts them. */
+given?: ReadonlyMap<string, Place>): TreeMapLayout;