@you-agent-factory/factory-visualizers 0.0.0 → 0.0.2

package/dist/factory-emulator-controls.d.ts

@@ -0,0 +1,26 @@
+import { type FactoryEmulatorControlsProps as PlaybackControlsProps } from "@you-agent-factory/components";
+import type { HTMLAttributes } from "react";
+import { type FactoryEmulatorFailure } from "./factory-emulator-error-boundary";
+import { type FactoryTimelineScrubberMessages, type FactoryTimelineScrubberState } from "./factory-timeline-scrubber";
+import type { FactoryVisualizerError } from "./visualizer-error";
+export interface FactoryEmulatorControlsProps extends Omit<HTMLAttributes<HTMLElement>, "children" | "onError">, Omit<PlaybackControlsProps, "onError" | "onPause" | "onPlay" | "onRestart" | "onStep"> {
+    formatTick: (tick: number) => string;
+    failure?: FactoryEmulatorFailure;
+    onFollowLatest: () => void;
+    onError?: (error: FactoryVisualizerError) => void;
+    onPause: () => void;
+    onPlay: () => void;
+    onRestart: () => void;
+    onSelectTick: (tick: number) => void;
+    onStep: () => void;
+    showPlaybackControls?: boolean;
+    showTimelineScrubber?: boolean;
+    timeline: FactoryEmulatorControlsTimeline;
+}
+export interface FactoryEmulatorControlsTimeline {
+    disabled?: boolean;
+    messages: FactoryTimelineScrubberMessages;
+    state: FactoryTimelineScrubberState;
+}
+/** Controlled controls that make the distinction between current and historical replay explicit. */
+export declare function FactoryEmulatorControls({ className, failure, formatTick, onFollowLatest, onError, onPause, onPlay, onRestart, onSelectTick, onStep, showPlaybackControls, showTimelineScrubber, timeline, ...playbackProps }: FactoryEmulatorControlsProps): import("react").JSX.Element;

package/dist/factory-emulator-error-boundary.d.ts

@@ -0,0 +1,26 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+import { type FactoryVisualizerError } from "./visualizer-error";
+/** A host-provided, safe-to-display local failure and optional recovery action. */
+export interface FactoryEmulatorFailure {
+    message: string;
+    recoveryAction?: {
+        label: string;
+        onRecover: () => void;
+    };
+}
+interface FactoryEmulatorErrorBoundaryProps {
+    children: ReactNode;
+    failure?: FactoryEmulatorFailure;
+    onError?: (error: FactoryVisualizerError) => void;
+    regionLabel: string;
+}
+interface FactoryEmulatorErrorBoundaryState {
+    error?: FactoryVisualizerError;
+}
+export declare class FactoryEmulatorErrorBoundary extends Component<FactoryEmulatorErrorBoundaryProps, FactoryEmulatorErrorBoundaryState> {
+    state: FactoryEmulatorErrorBoundaryState;
+    static getDerivedStateFromError(): FactoryEmulatorErrorBoundaryState;
+    componentDidCatch(error: unknown, _errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/dist/factory-emulator-view.d.ts

@@ -0,0 +1,27 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import { type FactoryEmulatorControlsProps } from "./factory-emulator-controls";
+import { type FactoryEmulatorFailure } from "./factory-emulator-error-boundary";
+import { type FactoryTopologyReplayProps } from "./factory-topology-replay";
+import type { FactoryTopologyReplayError } from "./visualizer-error";
+import { type WorkProgressVisualizerProps } from "./work-progress-visualizer";
+export type FactoryEmulatorViewPreset = "compact" | "display-only" | "full";
+export interface FactoryEmulatorViewVisibility {
+    playbackControls?: boolean;
+    runtimeStatus?: boolean;
+    speedControl?: boolean;
+    submission?: boolean;
+    timelineScrubber?: boolean;
+    workProgress?: boolean;
+}
+export interface FactoryEmulatorViewProps extends Omit<HTMLAttributes<HTMLElement>, "children" | "onError"> {
+    controls: FactoryEmulatorControlsProps;
+    failure?: FactoryEmulatorFailure;
+    onError?: (error: FactoryTopologyReplayError) => void;
+    preset?: FactoryEmulatorViewPreset;
+    submission?: ReactNode;
+    topology: FactoryTopologyReplayProps;
+    visibility?: FactoryEmulatorViewVisibility;
+    workProgress: WorkProgressVisualizerProps;
+}
+/** A controlled Factory emulator layout. Presets select regions; hosts retain all state and behavior. */
+export declare function FactoryEmulatorView({ className, controls, failure, onError, preset, submission, topology, visibility, workProgress, ...sectionProps }: FactoryEmulatorViewProps): import("react").JSX.Element;

package/dist/factory-recording-topology-replay.d.ts

@@ -0,0 +1,63 @@
+import { type FactoryRecording, type RecordingValidationIssue } from "@you-agent-factory/client";
+import { type FactoryActivityProjection, type FactoryLoadProjection, type FactoryTopologyNode, type FactoryTopologyProjection, type FactoryWorkProgressProjection } from "@you-agent-factory/factory-replay";
+import { type FactoryTimelineScrubberMessages } from "./factory-timeline-scrubber";
+import { type FactoryTopologyReplayMessages } from "./factory-topology-replay";
+import type { FactoryVisualizerError } from "./visualizer-error";
+import { type WorkProgressVisualizerMessages } from "./work-progress-visualizer";
+export interface FactoryRecordingValidationDiagnosticIssue {
+    category: RecordingValidationIssue["category"];
+    code: RecordingValidationIssue["code"];
+    path: readonly (number | string)[];
+}
+export interface FactoryRecordingValidationDiagnostic {
+    issues: readonly FactoryRecordingValidationDiagnosticIssue[];
+    kind: "recording-validation";
+    message: string;
+    recoverable: false;
+}
+export type FactoryRecordingTopologyReplayError = FactoryRecordingValidationDiagnostic | FactoryVisualizerError | import("./visualizer-error").FactoryVisualizationLayoutDiagnostic;
+export interface FactoryRecordingTopologyReplayMessages {
+    progress: WorkProgressVisualizerMessages;
+    regionLabel: string;
+    selectedTick: (formattedTick: string) => string;
+    timeline: FactoryTimelineScrubberMessages;
+    topology: FactoryTopologyReplayMessages;
+    validationFailed: string;
+}
+export interface FactoryRecordingTopologyReplayProps {
+    defaultSelectedTick?: number;
+    formatNumber: (value: number) => string;
+    /** Presentation-only content validated by the controlled topology renderer. */
+    layout?: unknown;
+    messages: FactoryRecordingTopologyReplayMessages;
+    onError?: (error: FactoryRecordingTopologyReplayError) => void;
+    onSelectNode?: (node: FactoryTopologyNode) => void;
+    recording?: unknown;
+    selectedNodeId?: string;
+    state?: FactoryRecordingTopologyReplayState;
+}
+export type FactoryRecordingTopologyReplayState = {
+    error: FactoryVisualizerError;
+    status: "failed";
+} | {
+    status: "loading";
+} | {
+    recording: unknown;
+    status: "ready";
+};
+interface RecordingProjection {
+    activity: FactoryActivityProjection;
+    load: FactoryLoadProjection;
+    progress: FactoryWorkProgressProjection;
+    topology: FactoryTopologyProjection;
+}
+export interface RecordingProjectionCache {
+    events?: FactoryRecording["events"];
+    projections: Map<number, RecordingProjection>;
+}
+export declare const MAX_CACHED_RECORDING_PROJECTIONS = 32;
+export declare function createRecordingProjectionCache(): RecordingProjectionCache;
+/** Validate and replay one caller-owned recording through the controlled visualizers. */
+export declare function FactoryRecordingTopologyReplay({ defaultSelectedTick, formatNumber, layout, messages, onError, onSelectNode, recording, selectedNodeId, state, }: FactoryRecordingTopologyReplayProps): import("react").JSX.Element;
+export declare function projectRecordingAtTick(events: FactoryRecording["events"], tick: number, cache: RecordingProjectionCache): RecordingProjection;
+export {};

package/dist/factory-timeline-scrubber.d.ts

@@ -0,0 +1,32 @@
+import { type HTMLAttributes } from "react";
+export type FactoryTimelineMode = "current" | "history";
+export type FactoryTimelineScrubberState = {
+    earliestTick: number;
+    latestTick: number;
+    mode: FactoryTimelineMode;
+    selectedTick: number;
+    status: "available";
+} | {
+    status: "unavailable";
+};
+export interface FactoryTimelineScrubberMessages {
+    alreadyFollowingLatest: string;
+    disabled: string;
+    followLatest: string;
+    historyMode: string;
+    currentMode: string;
+    position: (formattedSelectedTick: string, formattedLatestTick: string) => string;
+    regionLabel: string;
+    sliderLabel: string;
+    title: string;
+    unavailable: string;
+}
+export interface FactoryTimelineScrubberProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    disabled?: boolean;
+    formatTick: (tick: number) => string;
+    messages: FactoryTimelineScrubberMessages;
+    onFollowLatest: () => void;
+    onSelectTick: (tick: number) => void;
+    state: FactoryTimelineScrubberState;
+}
+export declare function FactoryTimelineScrubber({ className, disabled, formatTick, messages, onFollowLatest, onSelectTick, state, ...sectionProps }: FactoryTimelineScrubberProps): import("react").JSX.Element;

package/dist/factory-topology-active-work.d.ts

@@ -0,0 +1,11 @@
+import type { FactoryActivityProjection } from "@you-agent-factory/factory-replay";
+export interface FactoryTopologyActiveWorkRow {
+    durationTicks: number;
+    id: string;
+}
+export interface FactoryTopologyActiveWorkSummary {
+    overflowCount: number;
+    rows: readonly FactoryTopologyActiveWorkRow[];
+}
+/** Derives bounded, read-only Work activity from the prepared projection. */
+export declare function projectFactoryTopologyActiveWork(activity: FactoryActivityProjection): FactoryTopologyActiveWorkSummary;

package/dist/factory-topology-chrome.d.ts

@@ -0,0 +1,14 @@
+/** Optional presentation regions for the public, read-only Factory topology. */
+export type FactoryTopologyChromeRegion = "legend" | "background" | "viewportControls" | "visibilityControls";
+export type FactoryTopologyChromePreset = "full" | "minimal" | "none";
+export interface FactoryTopologyChromeConfiguration {
+    background?: boolean;
+    legend?: boolean;
+    preset?: FactoryTopologyChromePreset;
+    viewportControls?: boolean;
+    visibilityControls?: boolean;
+}
+export type ResolvedFactoryTopologyChrome = Readonly<Record<FactoryTopologyChromeRegion, boolean>>;
+export declare const DEFAULT_FACTORY_TOPOLOGY_CHROME_PRESET: FactoryTopologyChromePreset;
+/** Resolves presentation without receiving or changing replay projection data. */
+export declare function resolveFactoryTopologyChrome(configuration?: FactoryTopologyChromeConfiguration): ResolvedFactoryTopologyChrome;

package/dist/factory-topology-flow-projection.d.ts

@@ -0,0 +1,12 @@
+import type { Edge, Node } from "@xyflow/react";
+import type { FactoryVisualizationLayoutV1 } from "@you-agent-factory/client";
+import type { FactoryTopologyNode } from "@you-agent-factory/factory-replay";
+import type { FactoryTopologyReplayMessages, FactoryTopologyReplayProjection } from "./factory-topology-replay";
+import type { AnnotationNodeData, TopologyNodeData } from "./factory-topology-replay-nodes";
+export interface FactoryTopologyFlowProjection {
+    edges: Edge[];
+    nodes: Node<TopologyNodeData | AnnotationNodeData>[];
+    validEndpoints: boolean;
+}
+/** Convert immutable replay projections into disposable React Flow view data. */
+export declare function projectFactoryTopologyFlow(projection: FactoryTopologyReplayProjection, messages: FactoryTopologyReplayMessages, selectedNodeId: string | undefined, onSelectNode: ((node: FactoryTopologyNode) => void) | undefined, prefersReducedMotion?: boolean, layout?: FactoryVisualizationLayoutV1): FactoryTopologyFlowProjection;

package/dist/factory-topology-replay-nodes.d.ts

@@ -0,0 +1,32 @@
+import type { Node, NodeProps } from "@xyflow/react";
+import type { FactoryVisualizationAnnotation, FactoryVisualizationNodeEmptyState } from "@you-agent-factory/client";
+import type { FactoryTopologyNode } from "@you-agent-factory/factory-replay";
+import type { FactoryTopologyReplayMessages } from "./factory-topology-replay";
+export interface TopologyNodeData extends Record<string, unknown> {
+    activityCount: number;
+    emptyState?: FactoryVisualizationNodeEmptyState["content"];
+    messages: FactoryTopologyReplayMessages;
+    node: FactoryTopologyNode;
+    occupancy?: {
+        capacity?: number;
+        evidence: "known" | "unavailable";
+        occupied?: number;
+    };
+    onSelectNode?: (node: FactoryTopologyNode) => void;
+    selected: boolean;
+    workStateCount?: {
+        count?: number;
+        evidence: "known" | "unavailable";
+    };
+}
+export interface AnnotationNodeData extends Record<string, unknown> {
+    annotation: FactoryVisualizationAnnotation;
+    messages: FactoryTopologyReplayMessages;
+}
+export declare const nodeTypes: {
+    factoryTopologyAnnotation: typeof FactoryTopologyAnnotationView;
+    factoryTopologyNode: typeof FactoryTopologyNodeView;
+};
+declare function FactoryTopologyAnnotationView({ data, }: NodeProps<Node<AnnotationNodeData>>): import("react").JSX.Element;
+declare function FactoryTopologyNodeView({ data }: NodeProps<Node<TopologyNodeData>>): import("react").JSX.Element;
+export {};

package/dist/factory-topology-replay.d.ts

@@ -0,0 +1,61 @@
+import type { FactoryActivityProjection, FactoryLoadProjection, FactoryTopologyNode, FactoryTopologyProjection } from "@you-agent-factory/factory-replay";
+import { type FactoryTopologyChromeConfiguration } from "./factory-topology-chrome";
+export type { FactoryTopologyFlowProjection } from "./factory-topology-flow-projection";
+export { projectFactoryTopologyFlow } from "./factory-topology-flow-projection";
+import type { FactoryTopologyReplayError } from "./visualizer-error";
+export interface FactoryTopologyReplayProjection {
+    activity: FactoryActivityProjection;
+    load: FactoryLoadProjection;
+    topology: FactoryTopologyProjection;
+}
+export type FactoryTopologyReplayState = {
+    status: "empty";
+} | {
+    status: "failed";
+} | {
+    status: "loading";
+} | {
+    projection: FactoryTopologyReplayProjection;
+    status: "ready";
+};
+export interface FactoryTopologyReplayMessages {
+    activeDispatches: (count: number) => string;
+    /** Optional fields retain compatibility for existing controlled consumers. */
+    activeWorkDuration?: (durationTicks: number) => string;
+    activeWorkOverflow?: (count: number) => string;
+    activeWorkRegionLabel?: string;
+    annotationsHidden: string;
+    annotationsVisible: string;
+    empty: string;
+    failed: string;
+    inactiveDispatches: string;
+    imageFailed: string;
+    imageLoading: string;
+    /** Optional labels retain compatibility for existing controlled consumers. */
+    legendActiveRoute?: string;
+    legendInactiveRoute?: string;
+    legendLabel?: string;
+    loading: string;
+    nodeLabel: (kind: FactoryTopologyNode["kind"], label: string) => string;
+    regionLabel: string;
+    resourceOccupancy: (occupied: number, capacity: number) => string;
+    resourceOccupancyUnavailable: string;
+    retry: string;
+    selectedNode: string;
+    viewportControlsLabel?: string;
+    workStateCount: (count: number) => string;
+    workStateCountUnavailable: string;
+}
+export interface FactoryTopologyReplayProps {
+    /** Presentation-only optional chrome; it never changes the prepared projection. */
+    chrome?: FactoryTopologyChromeConfiguration;
+    /** Presentation-only input validated against the prepared canonical topology. */
+    layout?: unknown;
+    messages: FactoryTopologyReplayMessages;
+    onError?: (error: FactoryTopologyReplayError) => void;
+    onRetry?: () => void;
+    onSelectNode?: (node: FactoryTopologyNode) => void;
+    selectedNodeId?: string;
+    state: FactoryTopologyReplayState;
+}
+export declare function FactoryTopologyReplay(props: FactoryTopologyReplayProps): import("react").JSX.Element;

package/dist/factory-topology-state.d.ts

@@ -0,0 +1,31 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+import type { FactoryTopologyReplayMessages, FactoryTopologyReplayProps } from "./factory-topology-replay";
+import { type FactoryTopologyReplayError, type FactoryVisualizerError, type FactoryVisualizerErrorKind } from "./visualizer-error";
+export declare function FactoryTopologyStateRegion({ messages, onRetry, state, }: {
+    messages: FactoryTopologyReplayMessages;
+    onRetry?: () => void;
+    state: "empty" | "failed" | "loading";
+}): import("react").JSX.Element;
+interface FactoryTopologyErrorBoundaryProps {
+    children: ReactNode;
+    errorKind: Extract<FactoryVisualizerErrorKind, "react-flow" | "render">;
+    messages: FactoryTopologyReplayMessages;
+    onError?: (error: FactoryVisualizerError) => void;
+    onRetry?: () => void;
+    resetKeys: readonly unknown[];
+    withinRegion?: boolean;
+}
+interface FactoryTopologyErrorBoundaryState {
+    error?: FactoryVisualizerError;
+}
+export declare class FactoryTopologyErrorBoundary extends Component<FactoryTopologyErrorBoundaryProps, FactoryTopologyErrorBoundaryState> {
+    state: FactoryTopologyErrorBoundaryState;
+    private readonly reportedErrors;
+    static getDerivedStateFromError(): FactoryTopologyErrorBoundaryState;
+    componentDidCatch(error: unknown, _errorInfo: ErrorInfo): void;
+    componentDidUpdate(previousProps: FactoryTopologyErrorBoundaryProps): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+    private report;
+}
+export declare function useDistinctTopologyErrorReport(error: FactoryTopologyReplayError | undefined, onError: FactoryTopologyReplayProps["onError"]): void;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { FactoryEmulatorControls, type FactoryEmulatorControlsProps, type FactoryEmulatorControlsTimeline, } from "./factory-emulator-controls.js";
+export type { FactoryEmulatorFailure } from "./factory-emulator-error-boundary.js";
+export { FactoryEmulatorView, type FactoryEmulatorViewPreset, type FactoryEmulatorViewProps, type FactoryEmulatorViewVisibility, } from "./factory-emulator-view.js";
+export { FactoryRecordingTopologyReplay, type FactoryRecordingTopologyReplayError, type FactoryRecordingTopologyReplayMessages, type FactoryRecordingTopologyReplayProps, type FactoryRecordingTopologyReplayState, type FactoryRecordingValidationDiagnostic, type FactoryRecordingValidationDiagnosticIssue, } from "./factory-recording-topology-replay.js";
+export { type FactoryTimelineMode, FactoryTimelineScrubber, type FactoryTimelineScrubberMessages, type FactoryTimelineScrubberProps, type FactoryTimelineScrubberState, } from "./factory-timeline-scrubber.js";
+export { DEFAULT_FACTORY_TOPOLOGY_CHROME_PRESET, type FactoryTopologyChromeConfiguration, type FactoryTopologyChromePreset, type FactoryTopologyChromeRegion, type ResolvedFactoryTopologyChrome, resolveFactoryTopologyChrome, } from "./factory-topology-chrome.js";
+export { type FactoryTopologyFlowProjection, FactoryTopologyReplay, type FactoryTopologyReplayMessages, type FactoryTopologyReplayProjection, type FactoryTopologyReplayProps, type FactoryTopologyReplayState, projectFactoryTopologyFlow, } from "./factory-topology-replay.js";
+export type { FactoryTopologyReplayError, FactoryVisualizationLayoutDiagnostic, FactoryVisualizerError, FactoryVisualizerErrorCause, FactoryVisualizerErrorKind, } from "./visualizer-error.js";
+export { type WorkProgressCategoryMessage, WorkProgressVisualizer, type WorkProgressVisualizerMessages, type WorkProgressVisualizerProps, } from "./work-progress-visualizer.js";