@arbidocs/blocks 0.4.76 → 0.4.78

package/dist/agents/index.js

@@ -1,23 +1,23 @@
 "use client";
-export { AgentAvatarField, AgentBar, AgentBarIconButton, AgentBarMenu, AgentBarNotes, AgentBarProbeAnswer, AgentBarQueuedNote, AgentBarStatus, AgentCard, AgentCreateView, AgentCreatedView, AgentCreator, AgentEditView, AgentGallery, AgentMainView, AgentSelect, AgentTypeSelector, CapabilityGrid, CapabilityTile, ConfigField, ConfigForm, ConsentActions, ConsentBulletList, ConsentCard, ConsentFootnote, ConsentHeader, ConsentMessage, ConsentNotice, ConsentPage, ConsentPermissionList, ConsentSection, ConsentStrong, ConsentText, ConversationListView, ConversationTurnSpeaker, CopyableUrl, DEFAULT_AGENT_AVATAR_FIELD_LABELS, DEFAULT_AGENT_BAR_LABELS, DEFAULT_AGENT_CARD_LABELS, DEFAULT_AGENT_CREATOR_LABELS, DEFAULT_AGENT_GALLERY_LABELS, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_AGENT_STEPS_LABELS, DEFAULT_AGENT_TYPE_SELECTOR_LABELS, DEFAULT_AUTHORIZE_AGENT_LABELS, DEFAULT_CONFIG_FIELD_LABELS, DEFAULT_CONFIG_FORM_LABELS, DEFAULT_CONSENT_ACTIONS_LABELS, DEFAULT_COPYABLE_URL_LABELS, DEFAULT_NEW_THREAD_DIALOG_LABELS, DEFAULT_PILL_SELECT_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SKILL_CARD_LABELS, DEFAULT_SKILL_EDIT_FORM_LABELS, DEFAULT_SKILL_GENERATE_FORM_LABELS, DEFAULT_SKILL_GLOBAL_BADGE_LABELS, DEFAULT_SKILL_ROW_LABELS, DEFAULT_SKILL_VIEW_TOGGLE_LABELS, DEFAULT_SUBAGENT_ROSTER_LABELS, DEFAULT_TASKS_CHROME_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TASK_STATUS_PILL_LABELS, DEFAULT_TASK_THREAD_CHIP_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOWS_CHROME_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TASK_COLUMN_ORDER, TRIGGER_LABELS, TaskActivityDialog, TaskActivityTimeline, TaskComposer, TaskFlow, TaskInbox, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskRunsDialog, TaskStartDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, ThreadActivity, ThreadNotifyDialog, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowThreadStartedBy, WorkflowThreadStrip, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildRRule, buildTaskRows, buildWorkflowScopeSource, compactThreadActivity, composePersona, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, filterConversationRows, firstWords, formatElapsed, goalProgress, groupThreadActivity, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, isAgenticWorkflow, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isoToLocalInput, linkedRunsFromActivity, localInputToIso, matchWorkflowScope, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, resolveScopeInputs, skillSlug, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, useWorkflowPreview, workflowFromSkillMarkdown, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowToSkillMarkdown, workflowTriggerType, workflowWhen } from '../chunk-TKB7TVMW.js';
+export { AgentAvatarField, AgentBar, AgentBarIconButton, AgentBarMenu, AgentBarNotes, AgentBarProbeAnswer, AgentBarQueuedNote, AgentBarStatus, AgentCard, AgentCreateView, AgentCreatedView, AgentCreator, AgentEditView, AgentGallery, AgentMainView, AgentSelect, AgentTypeSelector, CapabilityGrid, CapabilityTile, ConfigField, ConfigForm, ConsentActions, ConsentBulletList, ConsentCard, ConsentFootnote, ConsentHeader, ConsentMessage, ConsentNotice, ConsentPage, ConsentPermissionList, ConsentSection, ConsentStrong, ConsentText, ConversationListView, ConversationTurnSpeaker, CopyableUrl, DEFAULT_AGENT_AVATAR_FIELD_LABELS, DEFAULT_AGENT_BAR_LABELS, DEFAULT_AGENT_CARD_LABELS, DEFAULT_AGENT_CREATOR_LABELS, DEFAULT_AGENT_GALLERY_LABELS, DEFAULT_AGENT_SELECT_LABELS, DEFAULT_AGENT_STEPS_LABELS, DEFAULT_AGENT_TYPE_SELECTOR_LABELS, DEFAULT_AUTHORIZE_AGENT_LABELS, DEFAULT_CONFIG_FIELD_LABELS, DEFAULT_CONFIG_FORM_LABELS, DEFAULT_CONSENT_ACTIONS_LABELS, DEFAULT_COPYABLE_URL_LABELS, DEFAULT_NEW_THREAD_DIALOG_LABELS, DEFAULT_PILL_SELECT_LABELS, DEFAULT_RECURRENCE, DEFAULT_RECURRENCE_BUILDER_LABELS, DEFAULT_SKILL_CARD_LABELS, DEFAULT_SKILL_EDIT_FORM_LABELS, DEFAULT_SKILL_GENERATE_FORM_LABELS, DEFAULT_SKILL_GLOBAL_BADGE_LABELS, DEFAULT_SKILL_ROW_LABELS, DEFAULT_SKILL_VIEW_TOGGLE_LABELS, DEFAULT_SUBAGENT_ROSTER_LABELS, DEFAULT_TASKS_CHROME_LABELS, DEFAULT_TASK_ACTIVITY_LABELS, DEFAULT_TASK_COMPOSER_LABELS, DEFAULT_TASK_LIST_LABELS, DEFAULT_TASK_OUTPUTS_CELL_LABELS, DEFAULT_TASK_PLAN_LABELS, DEFAULT_TASK_RUNS_DIALOG_LABELS, DEFAULT_TASK_STATUS_PILL_LABELS, DEFAULT_TASK_THREAD_CHIP_LABELS, DEFAULT_TASK_TRIGGER_CHIP_LABELS, DEFAULT_TUPLE_ARRAY_FIELD_LABELS, DEFAULT_UPLOAD_TASK_ITEM_LABELS, DEFAULT_UPLOAD_TASK_LIST_LABELS, DEFAULT_WORKFLOWS_CHROME_LABELS, DEFAULT_WORKFLOW_CONFIG_DIALOG_LABELS, DEFAULT_WORKFLOW_LIST_LABELS, DEFAULT_WORKFLOW_THREAD_STRIP_LABELS, DERIVED_NAME_WORDS, EMPTY_NEW_THREAD, GoalCriteria, MAX_TASK_DEPTH, NewThreadDialog, PersonPill, PillSelect, RecurrenceBuilder, STATUS_LABELS, STATUS_ORDER, STATUS_TONE, SkillActionButton, SkillCard, SkillDetail, SkillDetailSection, SkillEditForm, SkillFilterChips, SkillGenerateForm, SkillGlobalBadge, SkillRow, SkillTile, SkillTypeBadge, SkillViewToggle, StepDetail, StepNarration, StepOutcome, StepParams, StepRow, StepSummary, StepTrace, StepTraceSummary, SubAgentLane, SubStepGroup, SubagentRoster, TASK_COLUMN_ORDER, TRIGGER_LABELS, TaskActivityDialog, TaskActivityTimeline, TaskComposer, TaskFlow, TaskInbox, TaskMoveDialog, TaskOutputsCell, TaskPlan, TaskRunsDialog, TaskStartDialog, TaskStatusPill, TaskTable, TaskThreadChip, TaskTriggerChip, TasksToolbar, ThreadActivity, ThreadNotifyDialog, TupleArrayField, UploadTaskItem, UploadTaskList, WEEKDAYS, WORKFLOW_COLUMN_ORDER, WorkflowConfigDialog, WorkflowDocumentsField, WorkflowLauncher, WorkflowThreadStartedBy, WorkflowThreadStrip, WorkflowsTable, WorkflowsToolbar, agentConfigSectionToValues, agentCreatorToConfigSection, asTaskStatus, authModeFor, buildRRule, buildTaskRows, buildWorkflowScopeSource, compactThreadActivity, composePersona, composerToTaskQuery, composerToWorkRequest, composerToWorkflowRequest, composerToWorkflowUpdate, createTaskColumns, createWorkflowColumns, createsWork, defaultScopeRenderer, defaultTaskComposerValues, deriveAgentName, deriveWorkflowName, descendantIds, describeRRule, filterConversationRows, firstWords, formatElapsed, goalProgress, groupThreadActivity, hasTaskFields, hasTrigger, humanizeSection, indexTasks, inferType, inputDocumentIds, isAgenticWorkflow, isOutOfBounds, isPlainTodo, isSkillRow, isValidAgentName, isoToLocalInput, linkedRunsFromActivity, localInputToIso, matchWorkflowScope, moveTargets, newThreadToRequest, nextCriterionId, ownerExtId, parseRRule, prettifyKey, resolveScopeInputs, skillSlug, stripPersonaPreamble, summarizeAgent, summarizeCapabilities, taskComposerToCreateRequest, taskComposerToUpdateRequest, taskNeedsAccess, taskToComposerValues, useWorkflowPreview, workflowFromSkillMarkdown, workflowStatus, workflowTaskFields, workflowToComposerValues, workflowToSkillMarkdown, workflowTriggerType, workflowWhen } from '../chunk-5OC5CGYX.js';
 import '../chunk-CKB64Z4R.js';
 import '../chunk-P6GHJSLR.js';
-export { DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, SchemaForm, WorkflowRunner, buildLaunch, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, fieldToFrontmatter, fillRunText, fillStepInputs, fromPlanSteps, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isIncompleteSignal, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, layoutFromPlanSteps, nextAction, orderSteps, promptFieldName, reviewInstructions, runFields, runThreadTitle, skillToWorkflow, stepDependencies, stepLevels, stepPhase, stepStatesFromActivity, toPlanSteps, useWorkflowView, validateInputs, validateStep, validateWorkflowGraph, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost } from '../chunk-22P5KNIM.js';
+export { ActionStepBody, ApprovalEvidence, AssigneeLine, DEFAULT_ASSIGNEE_WORDING, DEFAULT_SCHEMA_FORM_LABELS, DEFAULT_STEP_BAR_LABELS, DEFAULT_WORKFLOW_RUNNER_LABELS, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, EMPTY_WORKFLOW_SCOPE, SKILL_PROMPT_FALLBACK_PLACEHOLDER, SKILL_PROMPT_LABEL, SchemaForm, SendBackControl, WorkflowRunner, activeStepId, assigneeName, buildLaunch, canAssign, composeStepPrompt, composeWorkflowPrompt, defaultInputs, dependsOn, fieldToFrontmatter, fillRunText, fillStepInputs, fromPlanAssignee, fromPlanDocumentRef, fromPlanSteps, initialRunInputs, inputsFromContext, isEmptyWorkflowScope, isIncompleteSignal, isPersonAction, isPersonStep, isRunFinished, isSteppedWorkflow, isWorkflowScope, layoutFromPlanSteps, nextAction, orderSteps, promptFieldName, reviewInstructions, runFields, runFieldsOf, runThreadTitle, sendBackTargets, skillToWorkflow, splitDocRef, stepConfigProblems, stepDependencies, stepFields, stepLevels, stepPhase, stepStatesFromActivity, stepWindow, toPlanAssignee, toPlanDocumentRef, toPlanSteps, upstreamSteps, useWorkflowView, validateInputs, validateStep, validateWorkflowGraph, workflowAccepts, workflowFromFrontmatter, workflowSteps, workflowsAccepting, workflowsForHost } from '../chunk-WXRCMIAE.js';
 import '../chunk-4WWM3GQ5.js';
+import '../chunk-DDF5GPIJ.js';
+import '../chunk-XD2M6LIG.js';
 import '../chunk-RFXJYIDV.js';
 import '../chunk-DPLRHEJZ.js';
 import '../chunk-EVUEIBNU.js';
 import '../chunk-NUNKSZKU.js';
 import '../chunk-YU2KUMGE.js';
 import '../chunk-ZPLG7QYF.js';
-import '../chunk-DDF5GPIJ.js';
-import '../chunk-XD2M6LIG.js';
 import '../chunk-S7PSMMRG.js';
-import '../chunk-76JDDMSP.js';
 import '../chunk-HOXKR26S.js';
 import '../chunk-AA3PT6KR.js';
 import '../chunk-SLSBJRWW.js';
 import '../chunk-NPLYHR2E.js';
+import '../chunk-76JDDMSP.js';
 import '../chunk-OXF2IFXG.js';
 import '../chunk-TX2ZICS7.js';
 import '../chunk-7F6CBP3Z.js';

package/dist/agents/tasks/TaskActivityTimeline.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-export type TaskActivityKind = 'created' | 'run_started' | 'awaiting_access' | 'access_granted' | 'done' | 'reopened' | 'failed' | 'participant_joined' | 'assistant_responded' | 'assistant_stopped' | 'artifact_created' | 'artifact_edited' | 'document_added' | 'document_removed' | 'notified' | 'step_started' | 'step_done' | 'step_skipped' | 'step_failed' | 'step_signal' | 'linked_run';
+export type TaskActivityKind = 'created' | 'run_started' | 'awaiting_access' | 'access_granted' | 'done' | 'reopened' | 'failed' | 'participant_joined' | 'assistant_responded' | 'assistant_stopped' | 'artifact_created' | 'artifact_edited' | 'document_added' | 'document_removed' | 'notified' | 'step_started' | 'step_done' | 'step_skipped' | 'step_failed' | 'step_waiting' | 'step_progress' | 'step_sent_back' | 'step_ready' | 'step_reminded' | 'step_signal' | 'linked_run';
 /** One event of a task's history, as the backend returns it (oldest first). */
 export interface TaskActivityEvent {
     external_id: string;

package/dist/agents/tasks/WorkflowThreadStrip.d.ts

@@ -1,14 +1,17 @@
 /**
- * The top bar of a thread that runs a workflow: the workflow's named steps (done, under way, still
- * to come), with everything that actually happened in the thread attached to the step it happened
+ * The top bar of a thread that runs a workflow: where the run is — the previous, current and next
+ * steps by name, the rest behind ‹ › and "…", parallel steps as a "+N" chip, and every running step
+ * out of view as "Working: <title>" (`StepBarFrame`, the same model as the runner's stepper) — with
+ * everything that actually happened in the thread attached to the step it happened
  * during — the assistant's turns, a draft sent back, people's messages and edits, notifications.
  * What happened before the first step or after the last stays as ordinary entries at either end.
  * Linked runs show too: a signal a step raised and the linked thread it started (after the step),
  * and, for a thread a signal started, "Started by <step> in <thread>" (before the steps).
  * A thread without a workflow shows `TaskFlow` instead.
  */
-import type { ReactNode } from 'react';
+import { type ReactNode } from 'react';
 import { type WorkflowStepPhase } from '../workflows/run';
+import { type StepBarLabels } from '../workflows/StepBarFrame';
 import type { WorkflowStep, WorkflowStepState } from '../workflows/types';
 import type { TaskFlowItem } from './TaskFlow';
 /** An activity entry, with what the strip needs to place it. */
@@ -44,6 +47,10 @@ export interface WorkflowThreadStripLabels {
     signalled: string;
     /** A linked thread's tooltip; `{signal}` is replaced. */
     linkedRun: string;
+    /** A step that waits for someone; `{name}` is replaced. */
+    waitingFor: string;
+    /** A step the work was sent back to. */
+    sentBack: string;
 }
 export declare const DEFAULT_WORKFLOW_THREAD_STRIP_LABELS: WorkflowThreadStripLabels;
 /** A linked thread a signal started, as the host names it. */
@@ -84,7 +91,11 @@ export interface WorkflowThreadStripProps {
     signals?: readonly WorkflowThreadSignal[];
     /** For a thread a signal started: where it came from. */
     startedBy?: WorkflowThreadOrigin;
+    /** Who a step is for, in words (`assigneeName`): shown on the step while it waits for them. */
+    assigneeOf?: (step: WorkflowStep) => string | undefined;
     labels?: Partial<WorkflowThreadStripLabels>;
+    /** The bar's own wording (arrows, "…", "Working: <title>", status words). */
+    barLabels?: Partial<StepBarLabels>;
     className?: string;
 }
 /** "Started by <step> in <thread>": a linked run's way back to the thread that started it. */
@@ -92,4 +103,4 @@ export declare function WorkflowThreadStartedBy({ origin, labels, }: {
     origin: WorkflowThreadOrigin;
     labels?: Partial<WorkflowThreadStripLabels>;
 }): import("react").JSX.Element;
-export declare function WorkflowThreadStrip({ steps, states, items, renderIcon, onSkip, renderStepAction, signals, startedBy, labels, className, }: WorkflowThreadStripProps): import("react").JSX.Element;
+export declare function WorkflowThreadStrip({ steps, states, items, renderIcon, onSkip, renderStepAction, signals, startedBy, assigneeOf, labels, barLabels, className, }: WorkflowThreadStripProps): import("react").JSX.Element;

package/dist/agents/workflows/SchemaForm.d.ts

@@ -20,6 +20,11 @@ export interface SchemaFormProps {
     renderDocuments?: (field: WorkflowField, value: WorkflowScope, onChange: (s: WorkflowScope) => void) => ReactNode;
     /** Maps an option's `icon` key to a mark. */
     renderIcon?: (key: string) => ReactNode;
+    /** Who a `person` field offers (the workspace's members); without them it takes an id. */
+    people?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
     /**
      * Plain Enter in a multi-line field submits the form (Shift+Enter inserts the newline), the
      * chat's own convention. Single-line fields submit natively.
@@ -34,4 +39,4 @@ export interface SchemaFormProps {
  * Renders a workflow's declared inputs as a form. Controlled: the caller owns `values` (see
  * `defaultInputs`) and decides when to validate (`validateInputs`) and show `errors`.
  */
-export declare function SchemaForm({ fields, values, onChange, errors, renderScope, renderDocuments, renderIcon, onEnterSubmit, testIdPrefix, labels, className, }: SchemaFormProps): import("react").JSX.Element;
+export declare function SchemaForm({ fields, values, onChange, errors, renderScope, renderDocuments, renderIcon, onEnterSubmit, people, testIdPrefix, labels, className, }: SchemaFormProps): import("react").JSX.Element;

package/dist/agents/workflows/StepBarFrame.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The frame both step bars share (`WorkflowStepBar` in a runner, `WorkflowThreadStrip` on a
+ * thread): `‹ … [previous] [CURRENT] [next] … ›`, from `stepWindow`. Each visible level shows one
+ * step by name (its pill is the host's), a parallel level adds a "+N" chip that lists the group,
+ * "…" on either side lists every step, and every running step the window does not show gets a
+ * "Working: <title>" pill at the end. The bar is a nav landmark; ←/→ (Home/End) move the window.
+ */
+import { type ReactNode } from 'react';
+import type { WorkflowStepPhase } from './run';
+import { type StepWindow, type StepWindowLevel, type StepWindowStep } from './stepWindow';
+export declare function PhaseMark({ phase, icon }: {
+    phase: WorkflowStepPhase;
+    icon?: ReactNode;
+}): import("react").JSX.Element;
+export interface StepBarLabels {
+    nav: string;
+    back: string;
+    forward: string;
+    /** The "…" before the window; `{count}` is replaced. */
+    hiddenBefore: string;
+    /** The "…" after the window; `{count}` is replaced. */
+    hiddenAfter: string;
+    /** The full list's heading; `{position}` and `{total}` are replaced. */
+    position: string;
+    /** A parallel group's chip; `{count}` is replaced. */
+    parallel: string;
+    inParallel: string;
+    /** A running step out of view; `{title}` is replaced. */
+    working: string;
+    /** Several more running out of view; `{count}` is replaced. */
+    moreWorking: string;
+    /** A step that waits for someone; `{name}` is replaced. */
+    waitingFor: string;
+    phases: Record<WorkflowStepPhase, string>;
+}
+export declare const DEFAULT_STEP_BAR_LABELS: StepBarLabels;
+/** A pill's colours: the status shows in the text colour as well as the icon. */
+export declare function stepPillTone(phase: WorkflowStepPhase, current: boolean): string;
+export declare const STEP_PILL = "flex min-w-0 items-center gap-1.5 whitespace-nowrap rounded-full border px-2.5 py-1 text-xs font-medium transition-colors";
+/** A label is the full title, cut with an ellipsis only when very long (in full in `title`). */
+export declare const STEP_LABEL = "min-w-[2.5rem] truncate";
+/** What follows a name on its pill ("Waiting for …"): cut before the name is. */
+export declare const STEP_EXTRA = "min-w-0 shrink-[6] truncate font-normal opacity-80";
+/** A step in the frame's lists: its title, for naming it. */
+export interface StepBarStep extends StepWindowStep {
+    title: string;
+}
+export interface StepBarFrameProps<T extends StepBarStep> {
+    levels: T[][];
+    phaseOf: (id: string) => WorkflowStepPhase;
+    /** The step in view (none = where the run is). */
+    current?: string | null;
+    /** Go to a step: from a group, the full list or a "Working" pill. */
+    onSelect: (id: string) => void;
+    /** The pill of a level's primary step (a button or a popover trigger). */
+    renderStep: (step: T, level: StepWindowLevel<T>, win: StepWindow<T>, narrow: boolean) => ReactNode;
+    /**
+     * What the step in view waits on ("Waiting for …"): on its pill when wide, on a line of its own
+     * when narrow (where the pill has room for its name only).
+     */
+    noteOf?: (id: string) => string | undefined;
+    /** What follows a level's pill (signals it raised…). */
+    renderAfter?: (level: StepWindowLevel<T>) => ReactNode;
+    /** Before the steps / after them: shown while the window is at that end. */
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    /** Steps that cannot be gone to (the completion marker). */
+    isSelectable?: (id: string) => boolean;
+    icon?: (step: T) => ReactNode;
+    disabled?: boolean;
+    labels?: Partial<StepBarLabels>;
+    tid: (suffix: string) => string;
+    className?: string;
+}
+export declare function StepBarFrame<T extends StepBarStep>({ levels, phaseOf, current, onSelect, renderStep, noteOf, renderAfter, leading, trailing, isSelectable, icon, disabled, labels, tid, className, }: StepBarFrameProps<T>): import("react").JSX.Element;

package/dist/agents/workflows/StepParts.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The runner's step parts beyond a form, an upload and an agent's answer: an action step (a
+ * signature, an email draft, a tabular review), a review's fields, its send-back and what it
+ * approved, the "Waiting for <person>" line, and "Open in Word" for a tracked-changes version.
+ * Everything that leaves the runner (opening a document, mail, a grid, the sign flow) goes through
+ * the host's `WorkflowRunnerActions`.
+ */
+import { type ReactNode } from 'react';
+import type { WorkflowRunView } from './useWorkflowView';
+import type { WorkflowActionStep, WorkflowAgentStep, WorkflowReviewStep, WorkflowStepState } from './types';
+/** Where the runner hands off to the host. Each is optional: absent, its button is not shown. */
+export interface WorkflowRunnerActions {
+    /** Open a document, or one version of it (`doc-…@v3`). */
+    openDocument?: (ref: string) => void;
+    /** Open the document of a signature step to sign it (the signer's turn). */
+    sign?: (step: WorkflowActionStep, state: WorkflowStepState) => void;
+    /** Open an email step's draft in native mail. */
+    openDraft?: (draftId: string, mailbox?: string) => void;
+    /** Open a finished tabular review's grid: its columns (labels) over its documents. */
+    openReview?: (tags: string[], documents: string[]) => void;
+    /** Open a tracked-changes version in the Word editor, to accept or reject the changes. */
+    openRedline?: (ref: string) => void;
+    /** Show a step's answer where it is in the thread. */
+    openMessage?: (messageId: string) => void;
+    /** The person on screen (`usr-…`): a signature offers "Open and sign" to its signers only. */
+    me?: string;
+}
+export interface WorkflowStepPartsLabels {
+    waitingFor: string;
+    sendBack: string;
+    sendBackTo: string;
+    sendBackNote: string;
+    cancel: string;
+    sentBackHere: string;
+    approvedBy: string;
+    approvedAt: string;
+    approvedWhat: string;
+    viewAnswer: string;
+    fieldsHeading: string;
+    signers: string;
+    signed: string;
+    notSigned: string;
+    openAndSign: string;
+    decline: string;
+    declineNote: string;
+    declineConfirm: string;
+    declined: string;
+    signedVersion: string;
+    preparingSign: string;
+    expires: string;
+    preparingDraft: string;
+    draftReady: string;
+    openDraft: string;
+    emailSent: string;
+    reviewRunning: string;
+    reviewDone: string;
+    openReview: string;
+    openInWord: string;
+    redlineHint: string;
+    someone: string;
+}
+export declare const DEFAULT_WORKFLOW_STEP_PARTS_LABELS: WorkflowStepPartsLabels;
+/** "Waiting for Sophie Lindqvist" on a step a person has to do. */
+export declare function AssigneeLine({ run, stepId, l, testId, }: {
+    run: WorkflowRunView;
+    stepId: string;
+    l: WorkflowStepPartsLabels;
+    testId: string;
+}): import("react").JSX.Element | null;
+/** A step reopened by a send-back says so. */
+export declare function SentBackNote({ state, l, testId, }: {
+    state: WorkflowStepState | undefined;
+    l: WorkflowStepPartsLabels;
+    testId: string;
+}): import("react").JSX.Element | null;
+/** "Send back" on a ready step: pick the earlier step to redo and say what needs to change. */
+export declare function SendBackControl({ run, step, l, testId, }: {
+    run: WorkflowRunView;
+    step: WorkflowReviewStep;
+    l: WorkflowStepPartsLabels;
+    testId: string;
+}): import("react").JSX.Element | null;
+/** What a completed review recorded: who approved, the answers and versions, the fields. */
+export declare function ApprovalEvidence({ run, step, actions, nameOfDoc, l, testId, }: {
+    run: WorkflowRunView;
+    step: WorkflowReviewStep;
+    actions?: WorkflowRunnerActions;
+    nameOfDoc?: (id: string) => string | undefined;
+    l: WorkflowStepPartsLabels;
+    testId: string;
+}): import("react").JSX.Element | null;
+/** "Open in Word" for an agent step that edited a document with tracked changes. */
+export declare function RedlineOpen({ step, state, actions, l, testId, }: {
+    step: WorkflowAgentStep;
+    state: WorkflowStepState | undefined;
+    actions?: WorkflowRunnerActions;
+    l: WorkflowStepPartsLabels;
+    testId: string;
+}): import("react").JSX.Element | null;
+/** A platform action step: where it is, and what its person can do now. */
+export declare function ActionStepBody({ step, run, actions, nameOfDoc, heading, l, testId, }: {
+    step: WorkflowActionStep;
+    run: WorkflowRunView;
+    actions?: WorkflowRunnerActions;
+    nameOfDoc?: (id: string) => string | undefined;
+    heading: ReactNode;
+    l: WorkflowStepPartsLabels;
+    testId: string;
+}): import("react").JSX.Element;

package/dist/agents/workflows/WorkflowRunner.d.ts

@@ -6,6 +6,7 @@
  */
 import { type ReactNode } from 'react';
 import { type SchemaFormProps } from './SchemaForm';
+import { type WorkflowRunnerActions, type WorkflowStepPartsLabels } from './StepParts';
 import type { WorkflowRunView } from './useWorkflowView';
 import type { WorkflowAgentStep, WorkflowDefinition, WorkflowReviewStep, WorkflowStep, WorkflowStepState, WorkflowUploadStep } from './types';
 export interface WorkflowRunnerLabels {
@@ -44,6 +45,8 @@ export interface WorkflowRunnerLabels {
     fileFailed: string;
     /** Continue on an upload step while its files are read; `{current}` and `{count}` are replaced. */
     readingFiles: string;
+    /** The primary button on an email step waiting to be sent. */
+    markSent: string;
 }
 export declare const DEFAULT_WORKFLOW_RUNNER_LABELS: WorkflowRunnerLabels;
 /** A file the upload step lists (what is in the run's workspace). */
@@ -55,7 +58,7 @@ export interface WorkflowRunnerFile {
     /** The upload step it was added on in this run (listed first there, and holds it while read). */
     addedFor?: string;
 }
-export interface WorkflowRunnerProps extends Pick<SchemaFormProps, 'renderScope' | 'renderDocuments' | 'renderIcon'> {
+export interface WorkflowRunnerProps extends Pick<SchemaFormProps, 'renderScope' | 'renderDocuments' | 'renderIcon' | 'people'> {
     workflow: WorkflowDefinition;
     run: WorkflowRunView;
     /** An agent step's output (its answer, a drafted document). */
@@ -73,7 +76,17 @@ export interface WorkflowRunnerProps extends Pick<SchemaFormProps, 'renderScope'
     renderStepNote?: (step: WorkflowStep, run: WorkflowRunView) => ReactNode;
     /** Replaces the finish screen. */
     renderComplete?: (run: WorkflowRunView) => ReactNode;
+    /** Leave out the stepper (the host shows it elsewhere, e.g. above the run's thread). */
+    hideStepBar?: boolean;
+    /** A narrow panel beside a thread: tighter cards, the full width they are given. */
+    compact?: boolean;
+    /** Where the runner hands off to the host: documents, the sign flow, mail, a review grid. */
+    actions?: WorkflowRunnerActions;
+    /** A document's name by id (chips show it instead of the id). */
+    nameOfDoc?: (id: string) => string | undefined;
     labels?: Partial<WorkflowRunnerLabels>;
+    /** The wording of action steps, assignees, send-backs and approvals. */
+    partsLabels?: Partial<WorkflowStepPartsLabels>;
     /**
      * Test ids: `<prefix>-step-<id>` (pill), `<prefix>-<id>` (body), `<prefix>-field-<name>`,
      * `<prefix>-next` / `-back`, `<prefix>-done`.
@@ -81,6 +94,6 @@ export interface WorkflowRunnerProps extends Pick<SchemaFormProps, 'renderScope'
     testIdPrefix?: string;
     className?: string;
 }
-export declare function WorkflowRunner({ workflow, run, renderAgentOutput, renderReview, onUpload, uploading, files, renderUpload, renderStepNote, renderComplete, renderScope, renderDocuments, renderIcon, labels, testIdPrefix, className, }: WorkflowRunnerProps): import("react").JSX.Element;
+export declare function WorkflowRunner({ workflow, run, renderAgentOutput, renderReview, onUpload, uploading, files, renderUpload, renderStepNote, renderComplete, renderScope, renderDocuments, renderIcon, people, actions, nameOfDoc, hideStepBar, compact, labels, partsLabels, testIdPrefix, className, }: WorkflowRunnerProps): import("react").JSX.Element;
 /** m:ss (h:mm:ss past an hour). */
 export declare function formatElapsed(ms: number): string;

package/dist/agents/workflows/WorkflowStepBar.d.ts

@@ -1,17 +1,14 @@
 /**
- * The run's stepper: the graph by depth (a sequence is one row, steps side by side stack in a
- * column). It shows every label while they fit the width it has; when they do not, only the step
- * in view keeps its label and the rest are icons (named on hover and to assistive technology).
- * Labels never run past their pill: a long title is cut with an ellipsis, in full in `title`.
+ * The run's stepper: where you are, what is done, what is next and what is still running. It
+ * names the previous, current and next steps of the graph (`StepBarFrame` over `stepLevels`); the
+ * rest is a click away (‹ ›, "…"), a parallel level is one step plus a "+N" chip, and a running
+ * step out of view shows as "Working: <title>". The run's completion is the last step.
  */
-import { type ReactNode } from 'react';
-import type { WorkflowStepPhase } from './run';
+import type { ReactNode } from 'react';
 import type { WorkflowRunView } from './useWorkflowView';
 import type { WorkflowStep } from './types';
-export declare function PhaseMark({ phase, icon }: {
-    phase: WorkflowStepPhase;
-    icon?: ReactNode;
-}): import("react").JSX.Element | null;
+import { PhaseMark, type StepBarLabels } from './StepBarFrame';
+export { PhaseMark };
 export interface WorkflowStepBarProps {
     run: WorkflowRunView;
     levels: WorkflowStep[][];
@@ -19,5 +16,6 @@ export interface WorkflowStepBarProps {
     doneIcon?: ReactNode;
     icon: (key?: string) => ReactNode;
     tid: (suffix: string) => string;
+    labels?: Partial<StepBarLabels>;
 }
-export declare function WorkflowStepBar({ run, levels, doneTitle, doneIcon, icon, tid, }: WorkflowStepBarProps): import("react").JSX.Element;
+export declare function WorkflowStepBar({ run, levels, doneTitle, doneIcon, icon, tid, labels, }: WorkflowStepBarProps): import("react").JSX.Element;

package/dist/agents/workflows/index.d.ts

@@ -7,9 +7,12 @@ export { defaultScopeRenderer, resolveScopeInputs } from './scopeRender';
 export { WorkflowLauncher, type WorkflowLauncherProps } from './WorkflowLauncher';
 export { buildWorkflowScopeSource, matchWorkflowScope, type WorkflowScopeDocument, type WorkflowScopeLabel, } from './workspaceScope';
 export { WorkflowDocumentsField, type WorkflowDocumentsFieldProps } from './WorkflowDocumentsField';
-export { workflowSteps, isSteppedWorkflow, stepDependencies, dependsOn, orderSteps, validateWorkflowGraph, stepLevels, stepStatesFromActivity, runFields, initialRunInputs, stepPhase, isRunFinished, isPersonStep, nextAction, validateStep, fillRunText, fillStepInputs, runThreadTitle, reviewInstructions, composeStepPrompt, type StepComposeOptions, type WorkflowActivityEvent, type WorkflowGraphProblem, type WorkflowStepPhase, type WorkflowNextAction, } from './run';
-export { toPlanSteps, fromPlanSteps, layoutFromPlanSteps, isIncompleteSignal, type TaskPlanStep, type ToPlanOptions, } from './planSteps';
+export { workflowSteps, isSteppedWorkflow, stepDependencies, dependsOn, orderSteps, validateWorkflowGraph, stepLevels, stepStatesFromActivity, runFields, initialRunInputs, stepPhase, isRunFinished, isPersonStep, nextAction, validateStep, fillRunText, fillStepInputs, runThreadTitle, reviewInstructions, composeStepPrompt, stepFields, runFieldsOf, isPersonAction, canAssign, upstreamSteps, sendBackTargets, stepConfigProblems, splitDocRef, assigneeName, DEFAULT_ASSIGNEE_WORDING, type AssigneeWording, type WorkflowStepProblem, type StepComposeOptions, type WorkflowActivityEvent, type WorkflowGraphProblem, type WorkflowStepPhase, type WorkflowNextAction, } from './run';
+export { toPlanSteps, fromPlanSteps, layoutFromPlanSteps, isIncompleteSignal, toPlanAssignee, fromPlanAssignee, toPlanDocumentRef, fromPlanDocumentRef, type TaskPlanStep, type ToPlanOptions, } from './planSteps';
 export { workflowToSkillMarkdown, workflowFromSkillMarkdown, skillSlug } from './skillMarkdown';
 export { useWorkflowView, type UseWorkflowViewOptions, type WorkflowRunView, } from './useWorkflowView';
 export { useWorkflowPreview, type UseWorkflowPreviewOptions } from './useWorkflowPreview';
 export { WorkflowRunner, DEFAULT_WORKFLOW_RUNNER_LABELS, type WorkflowRunnerProps, type WorkflowRunnerLabels, type WorkflowRunnerFile, } from './WorkflowRunner';
+export { stepWindow, activeStepId, type StepWindow, type StepWindowLevel, type StepWindowOptions, type StepWindowStep, } from './stepWindow';
+export { DEFAULT_STEP_BAR_LABELS, type StepBarLabels } from './StepBarFrame';
+export { ActionStepBody, ApprovalEvidence, AssigneeLine, SendBackControl, DEFAULT_WORKFLOW_STEP_PARTS_LABELS, type WorkflowRunnerActions, type WorkflowStepPartsLabels, } from './StepParts';

package/dist/agents/workflows/planSteps.d.ts

@@ -6,9 +6,15 @@
  */
 import type { components } from '@arbidocs/client';
 import { type StepComposeOptions } from './run';
-import type { WorkflowDefinition, WorkflowInputs, WorkflowSignal, WorkflowStep } from './types';
+import type { WorkflowAssignee, WorkflowDefinition, WorkflowDocumentRef, WorkflowInputs, WorkflowSignal, WorkflowStep } from './types';
 export type TaskPlanStep = components['schemas']['TaskPlanStep'];
+type StepAssignee = components['schemas']['StepAssignee'];
+type PlanDocumentRef = string | components['schemas']['StepDocumentRef'];
 export type TaskPlan = components['schemas']['TaskPlan'];
+export declare function toPlanAssignee(a: WorkflowAssignee): StepAssignee;
+export declare function fromPlanAssignee(a: StepAssignee | null | undefined): WorkflowAssignee | undefined;
+export declare function toPlanDocumentRef(ref: WorkflowDocumentRef): PlanDocumentRef;
+export declare function fromPlanDocumentRef(ref: PlanDocumentRef | null | undefined): WorkflowDocumentRef | undefined;
 export interface ToPlanOptions extends StepComposeOptions {
     /**
      * The run's inputs when it starts: prompts are composed with them. Fields not given yet (or
@@ -28,3 +34,4 @@ export declare function layoutFromPlanSteps(steps: TaskPlanStep[] | null | undef
     x: number;
     y: number;
 }> | undefined;
+export {};

package/dist/agents/workflows/run.d.ts

@@ -4,7 +4,7 @@
  * run's thread records it (`stepStatesFromActivity`). Pure functions, shared by the thread runner
  * (`useWorkflowThread`), the builder's preview and the thread's top bar.
  */
-import type { WorkflowAgentStep, WorkflowDefinition, WorkflowErrors, WorkflowInputs, WorkflowReviewStep, WorkflowStep, WorkflowStepState } from './types';
+import type { WorkflowActionStep, WorkflowAgentStep, WorkflowAssignee, WorkflowField, WorkflowDefinition, WorkflowErrors, WorkflowInputs, WorkflowReviewStep, WorkflowStep, WorkflowStepState } from './types';
 /** A stepped workflow's steps; empty for a single-run one. */
 export declare function workflowSteps(workflow: WorkflowDefinition): WorkflowStep[];
 export declare const isSteppedWorkflow: (workflow: WorkflowDefinition) => boolean;
@@ -45,23 +45,37 @@ export declare function stepLevels(steps: WorkflowStep[]): WorkflowStep[][];
 export interface WorkflowActivityEvent {
     kind: string;
     detail?: Record<string, unknown> | null;
+    actor_ext_id?: string | null;
     created_at?: string;
 }
-/** Each step's state from the thread's activity log (oldest first): its latest step event wins. */
+/**
+ * Each step's state from the thread's activity log (oldest first): its latest step event wins.
+ * A send-back reopens the steps it lists as pending (only the one it went `to` is `sentBack`); a
+ * `step_ready` records who was told and a `step_progress` what a waiting step now waits on, until
+ * the step's next change. Mirrors the server (`workflow_steps.progress`).
+ */
 export declare function stepStatesFromActivity(events: WorkflowActivityEvent[]): Record<string, WorkflowStepState>;
-/** Every field the run asks for: the launch form's, then each form step's. */
-export declare function runFields(workflow: WorkflowDefinition): import("./types").WorkflowField[];
+/** The fields a person fills in on a step: a form's inputs, a review's fields. */
+export declare function stepFields(step: WorkflowStep): WorkflowField[];
+/** The fields the steps ask for (forms and reviews), in plan order. */
+export declare const runFieldsOf: (steps: WorkflowStep[]) => WorkflowField[];
+/** Every field the run asks for: the launch form's, then each form's and review's. */
+export declare function runFields(workflow: WorkflowDefinition): WorkflowField[];
 /** A fresh run's inputs: every field at its default, then the prefills. */
 export declare function initialRunInputs(workflow: WorkflowDefinition, inputs?: WorkflowInputs): WorkflowInputs;
 /**
  * Where a step stands: `blocked` until everything it waits for has finished (done or skipped),
- * then `ready`, then its own status.
+ * then `ready`, then its own status (`waiting`: an action step waiting on its people).
  */
-export type WorkflowStepPhase = 'blocked' | 'ready' | 'running' | 'done' | 'skipped' | 'failed';
+export type WorkflowStepPhase = 'blocked' | 'ready' | 'running' | 'waiting' | 'done' | 'skipped' | 'failed';
 export declare function stepPhase(steps: WorkflowStep[], states: Record<string, WorkflowStepState>, id: string): WorkflowStepPhase;
 export declare const isRunFinished: (steps: WorkflowStep[], states: Record<string, WorkflowStepState>) => boolean;
-/** A step a person does (form, upload, review); agent steps run themselves. */
+/** A step a person does (form, upload, review); agent and action steps start by themselves. */
 export declare const isPersonStep: (step: WorkflowStep) => boolean;
+/** An action step whose waiting phase is a person's: signing, sending the email. */
+export declare const isPersonAction: (step: WorkflowStep) => step is WorkflowActionStep;
+/** A step that can have an assignee and a reminder: a person step, or a signature or email. */
+export declare const canAssign: (step: WorkflowStep) => boolean;
 /**
  * What the primary button does on the step in view:
  * - `complete`: finish this form, upload or review (approve) and move on;
@@ -72,8 +86,47 @@ export declare const isPersonStep: (step: WorkflowStep) => boolean;
  */
 export type WorkflowNextAction = 'complete' | 'move' | 'skip' | 'finish' | 'wait';
 export declare function nextAction(steps: WorkflowStep[], states: Record<string, WorkflowStepState>, current: string | null): WorkflowNextAction;
-/** A form step's problems (empty = it can move on); other steps have none. */
+/** A form's or a fielded review's problems (empty = it can move on); other steps have none. */
 export declare function validateStep(step: WorkflowStep, inputs: WorkflowInputs): WorkflowErrors;
+/** Every step `id` waits for, directly or through others, in plan order. */
+export declare function upstreamSteps(steps: WorkflowStep[], id: string): WorkflowStep[];
+/**
+ * Where a ready step can send the work back to: an earlier step it waits for that has something
+ * to redo (done, skipped or failed), nearest first.
+ */
+export declare function sendBackTargets(steps: WorkflowStep[], states: Record<string, WorkflowStepState>, id: string): WorkflowStep[];
+/** Something a step still needs before it can run, for the builder to point out. */
+export interface WorkflowStepProblem {
+    step: string;
+    missing: 'document' | 'signers' | 'recipients' | 'tags' | 'documents';
+}
+/** What the steps still need before they can run: an action's document, signers, … */
+export declare function stepConfigProblems(steps: WorkflowStep[]): WorkflowStepProblem[];
+/** A document version id (`doc-…@v3`) split into the document and its version. */
+export declare function splitDocRef(ref: string): {
+    id: string;
+    version?: number;
+};
+/** How an assignee that names no one directly is described. */
+export interface AssigneeWording {
+    runOwner: string;
+    projectLead: string;
+    /** `{field}`: the person field's label. */
+    input: string;
+}
+export declare const DEFAULT_ASSIGNEE_WORDING: AssigneeWording;
+/**
+ * Who a step is for, in words: the person it was announced to, the member it names, the person a
+ * form field holds (each through `nameOf`), else its role. Undefined when it names no one.
+ */
+export declare function assigneeName(assignee: WorkflowAssignee | undefined, options?: {
+    nameOf?: (id: string) => string | undefined;
+    inputs?: WorkflowInputs;
+    fields?: WorkflowField[];
+    /** Who the server told (the assignee resolved): wins over a role. */
+    announcedTo?: string | null;
+    wording?: Partial<AssigneeWording>;
+}): string | undefined;
 /**
  * Fill a step's `with` templates from the run's inputs: `{{a}}`, `{{a || b}}` (first non-blank).
  * A template that is exactly one bare reference passes the value through untouched.

package/dist/agents/workflows/stepWindow.d.ts

@@ -0,0 +1,59 @@
+/**
+ * What a step bar shows of a run: a window of a few levels of the graph (`stepLevels`) around the
+ * step in view — previous, current, next — with how many steps it hides on either side, each
+ * parallel level collapsed to one primary step plus the rest, and the running steps the window
+ * does not show (so work that is still going on is never out of sight). Pure: both bars
+ * (`WorkflowStepBar` in a runner, `WorkflowThreadStrip` on a thread) render from it.
+ */
+import type { WorkflowStepPhase } from './run';
+/** A step as far as the window is concerned. */
+export interface StepWindowStep {
+    id: string;
+}
+/** One level of the graph: a step, or steps that run side by side (a parallel group). */
+export interface StepWindowLevel<T extends StepWindowStep> {
+    index: number;
+    steps: T[];
+    /** The step the bar shows for the level: the running one, else the one in view, else … */
+    primary: T;
+    /** The level's other steps, behind a "+N" chip. */
+    others: T[];
+    /** Where the level stands relative to the step in view. */
+    role: 'previous' | 'current' | 'next' | 'other';
+}
+export interface StepWindow<T extends StepWindowStep> {
+    levels: StepWindowLevel<T>[];
+    /** The levels in the window, in order. */
+    visible: StepWindowLevel<T>[];
+    /** The window's first level and the one after its last. */
+    start: number;
+    end: number;
+    /** The level of the step in view. */
+    currentLevel: number;
+    /** Steps in the levels before and after the window. */
+    hiddenBefore: number;
+    hiddenAfter: number;
+    canBack: boolean;
+    canForward: boolean;
+    /** Running steps the bar does not show: outside the window, or collapsed in a group. */
+    runningHidden: T[];
+    /** 1-based position of the step in view among all steps, and how many there are. */
+    position: number;
+    total: number;
+}
+export interface StepWindowOptions<T extends StepWindowStep> {
+    levels: T[][];
+    phaseOf: (id: string) => WorkflowStepPhase;
+    /** The step in view; none (or unknown) = the step the run is at (`activeStepId`). */
+    current?: string | null;
+    /** The window's first level, as the arrows moved it; none = around the step in view. */
+    start?: number | null;
+    /** How many levels the window shows (3: previous, current, next). */
+    span?: number;
+}
+/**
+ * The step a run is at, when nothing else says which step is in view: a running one, else one
+ * waiting on someone, else one that failed, else one ready to do, else the last one.
+ */
+export declare function activeStepId<T extends StepWindowStep>(levels: T[][], phaseOf: (id: string) => WorkflowStepPhase): string | undefined;
+export declare function stepWindow<T extends StepWindowStep>({ levels: raw, phaseOf, current, start: requested, span, }: StepWindowOptions<T>): StepWindow<T>;