@astrosheep/keiyaku 4.5.19 → 4.5.21

package/build/src/cli/render/akuma-activity.d.ts

@@ -1,11 +1,108 @@
-import type { KillEvidence } from "../../akuma/akuma.js";
+import type { AkumaStatus, KillEvidence } from "../../akuma/akuma.js";
+import type { CallObservation } from "../../library/akuma-creation.js";
 import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
+import type { WaitObservedAkuma } from "../../akuma/fleet-execution.js";
 import type { ParsedCommand } from "../parse.js";
 import { type TextRenderContext } from "./terminal.js";
 export declare const DEFAULT_CONTEXT: TextRenderContext;
-export declare function associatedIdentity(id: string, alias?: string, contract?: DispatchAssociation): string;
+/**
+ * The one blessed ruler: a run of U+2500 exactly as wide as the frame head's
+ * widest line, marking the boundary between an observation frame and its content.
+ */
+export declare function frameRule(headLines: readonly string[]): string;
+type FleetTimeline = AkumaObservation["status"]["timeline"];
+type RenderedSnapshot = FleetTimeline;
+export declare function associatedIdentity(id: string, alias?: string, _contract?: DispatchAssociation): string;
 export declare function snapshotHeading(id: string, alias: string | undefined, contract: DispatchAssociation | undefined): readonly string[];
+/**
+ * The one place row prefixes live: time, optional source, mark, verb, content.
+ * A plain layout is the single-target grammar; a source layout adds the frozen
+ * source column a plural wait aligns across its selected set.
+ */
+type RowLayout = Readonly<{
+    head: (time: string | undefined, glyph: string, verb: string) => string;
+    continuation: () => string;
+    marker: (count: number) => string;
+}>;
+/**
+ * Shared snapshot activity rendering. Full snapshots focus known tool evidence;
+ * `latest` preserves compact callers' established newest-entry selection.
+ */
+export declare function snapshotActivityLines(snapshot: RenderedSnapshot, context: TextRenderContext, selection?: Readonly<{
+    latest?: boolean;
+}>): readonly string[];
+/** One command's append-only activity view, with a baseline and a final tail flush. */
+export type ActivityStream = ((snapshot: RenderedSnapshot) => readonly string[]) & Readonly<{
+    /** Seed the sequence cursor without spending the command's live evidence budget. */
+    seed: (snapshot: RenderedSnapshot) => void;
+    /** Emit the deferred tail exactly once before the command's conclusion. */
+    flush: () => readonly string[];
+}>;
+/**
+ * Append-only live view over one command's successive settled snapshots. The
+ * first three tools stream immediately; later tools wait in a two-row tail
+ * until the command ends. As a newer tool displaces an older tail candidate,
+ * its body becomes an in-place omission count. Narrative waits only while a
+ * preceding tail tool still decides its position.
+ */
+export declare function activityStream(context: TextRenderContext, layout?: RowLayout): ActivityStream;
+/** What a wait conclusion renders over: its observed and unobserved members. */
+export type WaitConclusionResult = Readonly<{
+    observations: readonly AkumaObservation[];
+    unobserved: readonly Readonly<{
+        id: string;
+        diagnostic: string;
+    }>[];
+}>;
+/** One selected Akuma's frozen identity, resolved before the first observation round. */
+export type WaitSelectedIdentity = Readonly<{
+    id: string;
+    alias?: string;
+}>;
+export type WaitObservationStream = Readonly<{
+    /** Freeze the selected set's identities so the source column is stable before the first row. */
+    select: (selected: readonly WaitSelectedIdentity[]) => void;
+    /** One observation round; returns the head frames and newly settled rows to print. */
+    observe: (observed: readonly WaitObservedAkuma[]) => readonly string[];
+    /** The wait's closing scoreboard, or the empty string when there is nothing to print. */
+    conclude: (result: WaitConclusionResult) => string;
+    streamed: () => boolean;
+}>;
+/**
+ * Live view over a wait's successive observation rounds, one append-only
+ * stream per selected Akuma. Each Akuma's stream opens with its identity frame
+ * — the identity and Contract association the observed facts carry — before any
+ * row; an already settled Akuma prints that frame and never replays backlog
+ * rows. `conclude` renders the closing rows once the wait ends: one row per
+ * observed Akuma in `<clock> <mark> <verb> — <duration>` grammar, with a target
+ * named for a multi-target scoreboard and no activity replay.
+ */
+export declare function waitObservationStream(context: TextRenderContext, options?: Readonly<{
+    now?: () => number;
+}>): WaitObservationStream;
+/** The identity a streamed observing call's head frame renders from its resolved birth. */
+export type ObservedCallHead = Readonly<{
+    id: string;
+    alias?: string;
+    contract: DispatchAssociation;
+    facts: readonly string[];
+}>;
+export type CallObservationStream = Readonly<{
+    observe: (status: AkumaStatus) => readonly string[];
+    conclude: (observation: CallObservation) => string;
+    opened: () => boolean;
+}>;
+/**
+ * Live view over one observing call: its identity frame and birth diagnostics
+ * open the stream once, settled rows follow as they arrive, and the return
+ * appends one conclusion in single-target wait grammar. The stream never
+ * replays its own activity as a final snapshot, and it never carries the
+ * birth receipt's cwd row.
+ */
+export declare function callObservationStream(context: TextRenderContext, head: ObservedCallHead, options?: Readonly<{
+    now?: () => number;
+}>): CallObservationStream;
 type SnapshotView = Readonly<{
     status: AkumaObservation["status"];
     contract: DispatchAssociation;
@@ -14,6 +111,7 @@ type SnapshotView = Readonly<{
 type SnapshotCoreOptions = Readonly<{
     alias?: string;
     facts?: readonly string[];
+    showAllowed?: boolean;
 }>;
 export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): string;
 export declare function killResultText(id: string, evidence: KillEvidence, alias?: string): string;