@huanban/rulego-editor-core 1.4.1 → 2.0.0

package/dist/core/endpoint-protocol.d.ts

@@ -0,0 +1,15 @@
+export interface EndpointBindingSnapshot {
+    key: string;
+    path: unknown;
+    targets: string[];
+}
+interface RouterTarget {
+    prefix: string;
+    targets: string[];
+    implicit: boolean;
+}
+export declare function parseLocalRouterTarget(path: unknown, chainId: string, firstNodeId?: string): RouterTarget | undefined;
+export declare function snapshotEndpointBindings(endpoint: any, chainId: string, firstNodeId: string | undefined, nodeIds: Set<string>): EndpointBindingSnapshot[];
+export declare function endpointRouterMatchesConnection(endpoint: any, router: any, connection: any): boolean;
+export declare function reconcileEndpointBindings(endpoint: any, chainId: string, connections: any[], snapshot?: EndpointBindingSnapshot[], firstNodeId?: string): void;
+export {};

package/dist/core/expression-preview.d.ts

@@ -0,0 +1,6 @@
+import { type RuntimeFieldMessage } from './runtime-field-dictionary';
+export interface ExpressionPreviewResult {
+    text: string;
+    partial: boolean;
+}
+export declare function previewTemplate(value: unknown, message?: RuntimeFieldMessage | null): ExpressionPreviewResult | null;

package/dist/core/field-protocol.d.ts

@@ -1,4 +1,5 @@
-import type { ComponentDefinition, ComponentField, FieldDependency } from '../types/component';
+import type { ComponentDefinition, ComponentField, ComponentFieldGroup, FieldDependency } from '../types/component';
+import type { FieldChangeRegistry, FieldChangeResult } from './FieldChangeRegistry';
 export interface ResolveComponentFieldsContext {
     configuration?: Record<string, unknown>;
     getFieldsByType?: (type: string) => ComponentField[] | undefined;
@@ -13,20 +14,34 @@ export interface FieldValidationError {
     field: string;
     message: string;
 }
+export type FieldDependencyInput = FieldDependency;
+export interface FieldNumericBounds {
+    min?: number;
+    max?: number;
+}
 export declare function getMapValueMode(field: Pick<ComponentField, 'component' | 'capabilities'> & Record<string, unknown>): MapValueMode;
 export declare function formatMapEntryValue(value: unknown, mode?: MapValueMode): string;
 export declare function parseMapEntryValue(value: string, mode?: MapValueMode): unknown;
 export declare function getFieldAttachmentTarget(attachTo: ComponentField['attachTo']): string | undefined;
 export declare function normalizeComponentField(field: ComponentField): ComponentField;
+export declare function resolveFieldPlaceholder(field: ComponentField): string;
+export declare function getFieldNumericBounds(field: ComponentField): FieldNumericBounds;
+export declare function resolveComponentFieldGroups(component: ComponentDefinition): ComponentFieldGroup[];
 export declare function getFieldPathValue(source: unknown, path: string): unknown;
-export declare function validateFieldValue(field: ComponentField, value: unknown): string[];
-export declare function validateComponentFields(fields: ComponentField[] | undefined, configuration: Record<string, unknown>): FieldValidationError[];
-export declare function evaluateFieldDependency(dependency: FieldDependency, configuration: Record<string, unknown>): boolean;
+export type FieldValidationTranslator = (key: string, params?: Record<string, string>) => string;
+export declare function fieldValidationText(key: string, fallback: string, t?: FieldValidationTranslator, params?: Record<string, string | number>): string;
+export declare function validateFieldValue(field: ComponentField, value: unknown, t?: FieldValidationTranslator): string[];
+export declare function validateComponentFields(fields: ComponentField[] | undefined, configuration: Record<string, unknown>, t?: FieldValidationTranslator): FieldValidationError[];
+export declare function evaluateFieldDependency(dependency: FieldDependencyInput, configuration: Record<string, unknown>): boolean;
 export declare function isFieldDependencySatisfied(field: ComponentField, configuration: Record<string, unknown>): boolean;
 export declare function resolveComponentFields(component: ComponentDefinition, context?: ResolveComponentFieldsContext): ComponentField[];
 export declare function getVisibleComponentFields(fields: ComponentField[], configuration: Record<string, unknown>): ComponentField[];
 export declare function buildFieldAttachments(fields: ComponentField[]): Map<string, FieldAttachmentEntry[]>;
 export declare function parseUnknownConfiguration(text: string): Record<string, unknown>;
 export declare function cloneConfiguration(configuration: Record<string, unknown> | undefined): Record<string, unknown>;
+export declare function formatJsonTextFields(configuration: Record<string, unknown>, fields: ComponentField[]): Record<string, unknown>;
+export declare function parseJsonTextFields(configuration: Record<string, unknown>, fields: ComponentField[]): Record<string, unknown>;
+export declare function redisCmdOutputTo(value: unknown, configuration: Readonly<Record<string, unknown>>): FieldChangeResult | undefined;
+export declare function registerBuiltinFieldChangeHandlers(registry: Pick<FieldChangeRegistry, 'register'>): void;
 export declare function sanitizeConfigurationByFields(configuration: Record<string, unknown> | undefined, fields: ComponentField[] | undefined): Record<string, unknown>;
 export declare function buildDefaultConfiguration(component: ComponentDefinition, getFieldsByType?: (type: string) => ComponentField[] | undefined): Record<string, unknown>;

package/dist/core/global-config.d.ts

@@ -0,0 +1,47 @@
+export declare const GLOBAL_CONFIG_MASK = "******";
+export type GlobalConfigValues = Record<string, unknown>;
+export type GlobalConfigPatch = Record<string, string | null>;
+export interface GlobalConfigRow {
+    key: string;
+    value: string;
+    masked: boolean;
+    overridden: boolean | null;
+}
+export interface GlobalConfigReloadResult {
+    reloadedChains: string[];
+    reloadedNodes: string[];
+    failedChains: Record<string, string>;
+    failedNodes: Record<string, string>;
+}
+export interface GlobalConfigFetcher {
+    getGlobalConfig(signal?: AbortSignal): Promise<GlobalConfigValues>;
+    getGlobalOverrides(signal?: AbortSignal): Promise<GlobalConfigValues>;
+    updateGlobalConfig(patch: GlobalConfigPatch, signal?: AbortSignal): Promise<GlobalConfigReloadResult>;
+    revertGlobalConfigKey(key: string, signal?: AbortSignal): Promise<GlobalConfigReloadResult>;
+    captureContext?(): () => boolean;
+}
+export type GlobalConfigErrorCode = 'keyRequired' | 'valueRequired' | 'maskedPlaceholder' | 'duplicateKey' | 'invalidResponse' | 'missingApiBase' | 'contextChanged';
+export declare class GlobalConfigError extends Error {
+    readonly code: GlobalConfigErrorCode;
+    constructor(code: GlobalConfigErrorCode);
+}
+export declare function isSensitiveGlobalConfigKey(key: string): boolean;
+export declare function normalizeGlobalConfigValues(value: unknown): GlobalConfigValues;
+export declare function createGlobalConfigRows(config: GlobalConfigValues, overrides: GlobalConfigValues | null): GlobalConfigRow[];
+export declare function createGlobalConfigPatch(key: string, value: string, options?: {
+    masked?: boolean;
+    existingKeys?: Iterable<string>;
+}): GlobalConfigPatch | null;
+export declare function normalizeGlobalConfigReload(value: unknown): GlobalConfigReloadResult;
+export interface NodeBusinessLogConfig {
+    before?: string;
+    after?: string;
+}
+export interface ChainBusinessLogSettings {
+    handler: string;
+    chainEnd: boolean;
+}
+export declare function readNodeBusinessLog(model: Record<string, unknown>): Required<NodeBusinessLogConfig>;
+export declare function withNodeBusinessLog(model: Record<string, unknown>, before: string, after: string): Record<string, unknown>;
+export declare function readChainBusinessLog(configuration: Record<string, unknown>): ChainBusinessLogSettings;
+export declare function withChainBusinessLog(configuration: Record<string, unknown>, handler: string, chainEnd: boolean): Record<string, unknown>;

package/dist/core/global-search.d.ts

@@ -0,0 +1,31 @@
+export interface GlobalSearchResult {
+    chainId: string;
+    chainName: string;
+    nodeId: string;
+    nodeName: string;
+    nodeType: string;
+    matchField: 'name' | 'type' | 'configuration';
+    matchValue: string;
+    matchContext?: string;
+}
+export interface GlobalSearchProvider {
+    search(query: string, options?: {
+        maxResults?: number;
+    }): Promise<GlobalSearchResult[]>;
+}
+interface SearchableChain {
+    id: string;
+    name: string;
+    data: {
+        metadata?: {
+            nodes?: Array<{
+                id?: string;
+                type?: string;
+                name?: string;
+                configuration?: Record<string, unknown>;
+            }>;
+        };
+    };
+}
+export declare function createLocalGlobalSearch(getChains: () => SearchableChain[]): GlobalSearchProvider;
+export {};

package/dist/core/group-protocol.d.ts

@@ -0,0 +1,56 @@
+export declare const GROUP_NODE_TYPES: string[];
+export declare const LOOP_GROUP_TYPES: string[];
+export interface GroupProtocolNode {
+    id: string;
+    type?: string;
+    x?: number;
+    y?: number;
+    children?: unknown;
+    properties?: Record<string, any>;
+}
+export interface GroupProtocolGraph {
+    nodes: GroupProtocolNode[];
+    edges?: Array<{
+        id: string;
+        sourceNodeId: string;
+        targetNodeId: string;
+    }>;
+}
+export declare function positiveDimension(...values: unknown[]): number | undefined;
+export declare function groupChildIds(value: unknown): string[];
+export declare function getExpandedGroupLayout(node: GroupProtocolNode, runtime?: any): {
+    layoutX: number;
+    layoutY: number;
+    layoutW: number;
+    layoutH: number;
+    isCollapsed: boolean;
+};
+export declare function isLoopGroup(node: GroupProtocolNode | undefined): boolean;
+export declare function localLoopTarget(value: unknown): string | undefined;
+export declare function getGroupOwnership(nodes: GroupProtocolNode[]): Map<string, string>;
+export declare function getGroupAncestors(nodeId: string, ownership: Map<string, string>): string[];
+export interface GroupBoundaryIssue {
+    rule: 'group-own-container-edge' | 'group-cross-boundary';
+    sourceNodeId: string;
+    targetNodeId: string;
+    sourceGroups: string[];
+    targetGroups: string[];
+}
+export declare function inspectGroupBoundary(sourceNodeId: string, targetNodeId: string, ownership: Map<string, string>): GroupBoundaryIssue | null;
+export interface LoopEntryState {
+    groupId: string;
+    value: unknown;
+    targetId?: string;
+    status: 'not-loop' | 'unset' | 'external' | 'missing' | 'outside-group' | 'member';
+}
+export declare function getLoopEntryState(graph: GroupProtocolGraph, groupId: string): LoopEntryState;
+export interface GraphDeletionImpact {
+    nodeIds: string[];
+    edgeIds: string[];
+    loopEntryGroupIds: string[];
+    requiresConfirmation: true;
+}
+export declare function getGraphDeletionImpact(graph: GroupProtocolGraph, selection: {
+    nodeIds?: string[];
+    edgeIds?: string[];
+}): GraphDeletionImpact;

package/dist/core/identity-provider-default.d.ts

@@ -0,0 +1,32 @@
+import type { AuthChangeCallback, AuthErrorDetails, IdentityProvider, LoginCredentials, LoginResult, UserIdentity } from './IdentityProvider';
+export interface DefaultIdentityProviderOptions {
+    apiBase?: string;
+    customFetch?: (url: string, init?: RequestInit) => Promise<Response>;
+    tokenKey?: string;
+    tokenFallbackKey?: string;
+    userKey?: string;
+    onAuthRequired?: (details: AuthErrorDetails) => void;
+}
+export declare class DefaultIdentityProvider implements IdentityProvider {
+    private readonly options;
+    private readonly listeners;
+    private cachedUser;
+    private contextGeneration;
+    constructor(options?: DefaultIdentityProviderOptions);
+    updateContext(options: Pick<DefaultIdentityProviderOptions, 'apiBase' | 'customFetch' | 'onAuthRequired'>): void;
+    cancelPendingLogin(): void;
+    getToken(): string | null;
+    clearToken(): void;
+    setToken(token: string): void;
+    getCurrentUser(): UserIdentity | null;
+    isAuthenticated(): boolean;
+    login(credentials: LoginCredentials): Promise<LoginResult>;
+    logout(): Promise<void>;
+    onAuthChange(callback: AuthChangeCallback): () => void;
+    handleAuthError(details: AuthErrorDetails): Promise<boolean>;
+    private fetchCurrentUser;
+    private readStoredUser;
+    private storeUser;
+    private notifyListeners;
+}
+export declare function createDefaultIdentityProvider(options?: DefaultIdentityProviderOptions): DefaultIdentityProvider;

package/dist/core/index.d.ts

@@ -1,6 +1,8 @@
 export { StateStore } from './StateStore';
 export { EventBus } from './EventBus';
 export { DEFAULT_RUNTIME_FIELD_MAX_DEPTH, DEFAULT_RUNTIME_FIELD_MAX_PATHS, DEFAULT_RUNTIME_FIELD_SAMPLE_LENGTH, RuntimeFieldDictionary, extractRuntimeFieldPaths, mergeRuntimeFieldCompletions, } from './runtime-field-dictionary';
+export { previewTemplate } from './expression-preview';
+export type { ExpressionPreviewResult } from './expression-preview';
 export type { RuntimeFieldCompletionItem, RuntimeFieldConnection, RuntimeFieldDictionaryListener, RuntimeFieldDictionaryOptions, RuntimeFieldEvent, RuntimeFieldMessage, RuntimeFieldPath, RuntimeFieldSlot, RuntimeNodeFieldEntry, } from './runtime-field-dictionary';
 export { DataAdapter } from './DataAdapter';
 export type { LFNodeData, LFEdgeData, LFGraphData, LFPoint } from './DataAdapter';
@@ -12,7 +14,12 @@ export { ValidationEngine } from './ValidationEngine';
 export type { ValidationError, ValidationResult, ValidationRule, ValidationContext, } from './ValidationEngine';
 export { ThemeManager, THEME_LIGHT, THEME_DARK, THEME_BLUE } from './ThemeManager';
 export type { ThemeVariables, ThemeDefinition } from './ThemeManager';
-export { I18nManager, i18nText } from './I18nManager';
+export { I18nManager, i18nText, normalizeLocale } from './I18nManager';
+export { PropertyControlRegistry } from './PropertyControlRegistry';
+export type { PropertyControlRenderer, PropertyControlInstance, PropertyControlMountContext } from './PropertyControlRegistry';
+export { localizeComponentDefinition, localizeComponentFields, localizeComponentGroups, normalizeComponentLocaleMessages, applyComponentLocaleMetadata } from './component-localization';
+export { extractAssistantRuleChain, extractRuleChainFromToolCalls, hasDestructiveRuleChainChanges } from './assistant-dsl';
+export type { AssistantRuleChain } from './assistant-dsl';
 export type { LocaleMessages, TranslationSource } from './I18nManager';
 export { EditorCore } from './EditorCore';
 export { getEditorToolbarIconSvg, isEditorToolbarIconName, renderEditorToolbarIcon } from './toolbar-icons';
@@ -36,16 +43,24 @@ export type { OptionSourceContext, OptionSourceResolveContext, OptionSourceResol
 export { FieldChangeHandlerNotFoundError, FieldChangeRegistry, getFieldChangeHandlerName, } from './FieldChangeRegistry';
 export type { FieldChangeContext, FieldChangeExecutionResult, FieldChangeExecutionStatus, FieldChangeHandler, FieldChangeResolveContext, FieldChangeResult, } from './FieldChangeRegistry';
 export { buildFieldAttachments, buildDefaultConfiguration, cloneConfiguration, evaluateFieldDependency, formatMapEntryValue, getFieldAttachmentTarget, getFieldPathValue, getMapValueMode, getVisibleComponentFields, isFieldDependencySatisfied, parseUnknownConfiguration, parseMapEntryValue, resolveComponentFields, sanitizeConfigurationByFields, validateComponentFields, validateFieldValue, } from './field-protocol';
-export type { FieldAttachmentEntry, FieldValidationError, MapValueMode, ResolveComponentFieldsContext } from './field-protocol';
+export type { FieldAttachmentEntry, FieldValidationError, FieldValidationTranslator, MapValueMode, ResolveComponentFieldsContext } from './field-protocol';
 export { alignGraphNodes, cloneGraphSelection, insertGraphNodeOnEdge, reserveUniqueGraphElementId, distributeGraphNodes, selectConnectedNodeIds, snapGraphNodesToGrid, } from './graph-operations';
 export type { AlignMode, CloneGraphSelectionOptions, ClonedGraphSelection, DistributeMode, InsertGraphNodeOnEdgeOptions, InsertGraphNodeOnEdgeResult, } from './graph-operations';
 export { DiagnosticService } from './DiagnosticService';
 export { groupDiagnosticsByElement, validateTopology } from './topology-rules';
 export type { DiagnosticItem, TopologyContext } from './topology-rules';
-export { buildComponentPalette, normalizeComponentCategory, DEFAULT_COMPONENT_CATEGORY_ORDER } from './component-palette';
+export { buildComponentPalette, normalizeComponentCategory, DEFAULT_COMPONENT_CATEGORY_ORDER, hasDeclaredSubgroups, SUBGROUPED_COMPONENT_CATEGORIES } from './component-palette';
 export type { ComponentPaletteBuildOptions, ComponentPaletteGroup, ComponentPaletteSubgroup } from './component-palette';
 export { ComponentDocService } from './ComponentDocService';
 export type { ComponentDoc, ComponentDocMeta, ComponentDocProvider } from './ComponentDocService';
+export { createDefaultDialogProvider } from './DialogProvider';
+export type { DialogProvider, ConfirmOptions, PromptOptions, AlertOptions, DefaultDialogProviderOptions } from './DialogProvider';
+export { cleanSnapshot, cleanSnapshotString, sameCleanSnapshot, getVolatileKeys, createDirtySuppression, } from './clean-snapshot';
+export type { DirtySuppressionOptions, DirtySuppression, } from './clean-snapshot';
+export { createVariableCompletionSource } from './variable-completion';
+export type { VariableCompletionItem, VariableCompletionSource, } from './variable-completion';
+export type { NodeLogTemplate, ChainLogConfig, BusinessLogAPI } from './business-log-config';
+export type { ToolCallResult } from './assistant-dsl';
 export { buildExplorerTree, expandedExplorerKeys, explorerAncestorKeys, findExplorerNode, normalizeExplorerExpandedKeys, EXPLORER_SECTION_ROOT, EXPLORER_SECTION_SUB, } from './explorer-tree';
 export type { ExplorerTreeNode, ExplorerTreeNodeKind, ExplorerTreeLabels, ExplorerTreeOptions } from './explorer-tree';
 export { parseExcelTable, serializeExcelTable } from './table-spreadsheet';
@@ -67,8 +82,8 @@ export { ConnectionStatusController, ConnectionStatusStore, normalizeConnectionS
 export type { ConnectionStatusControllerOptions, ConnectionStatusMap, ConnectionStatusPhase, ConnectionStatusProvider, ConnectionStatusSemanticKind, ConnectionStatusState, ConnectionStatusTranslator, ConnectionStatusView, NodeConnectionState, NodeConnectionStatus, } from './connection-status';
 export { isEditorNodeRunTarget } from './hover-tools';
 export type { EditorHoverToolPosition, EditorHoverToolTarget, EditorNodeRunTarget, EditorNodeHoverAction, EditorEdgeHoverAction, } from './hover-tools';
-export { resolveEditorCapabilities, resolveCapabilities, CAPABILITY_BASE, CAPABILITY_PROFILES, } from './editor-capabilities';
-export type { EditorMode, EditorUiCapabilities, EditorCapabilities, EditorCapabilitiesOverride, EditorCapabilityInput, } from './editor-capabilities';
+export { resolveEditorCapabilities, mergeEditorCapabilities, mergeEditorToolbarOptions, resolveCapabilities, CAPABILITY_BASE, CAPABILITY_PROFILES, } from './editor-capabilities';
+export type { EditorMode, EditorUiCapabilities, EditorCapabilities, EditorCapabilitiesOverride, EditorCapabilityInput, EditorToolbarOptions, EditorToolbarRegion, EditorToolbarRegionOptions, EditorToolbarEntry, EditorToolbarButtonPresentation, EditorHeaderOptions, } from './editor-capabilities';
 export { autoLayout, needsAutoLayout } from './AutoLayout';
 export type { AutoLayoutOptions } from './AutoLayout';
 export { calculateVirtualWindow, DEFAULT_VIRTUAL_WINDOW_ITEM_HEIGHT, DEFAULT_VIRTUAL_WINDOW_VIEWPORT_HEIGHT, DEFAULT_VIRTUAL_WINDOW_OVERSCAN, DEFAULT_VIRTUAL_WINDOW_THRESHOLD, } from './virtual-window';
@@ -85,4 +100,15 @@ export { RuleChainValidator } from './RuleChainValidator';
 export type { ValidationIssue, ValidationResult as RuleChainValidationResult, IssueSeverity, } from './RuleChainValidator';
 export { EDITOR_OVERLAY_LAYERS, EDITOR_OVERLAY_LAYER_CSS_VARIABLES, EDITOR_OVERLAY_LAYER_CSS_TEXT, } from './overlay-layers';
 export type { EditorOverlayLayerName } from './overlay-layers';
+export { bindAnchoredPopover } from './anchored-popover';
+export type { AnchoredPopoverOptions, AnchoredPopoverBinding } from './anchored-popover';
 export { RUNTIME_LIMITS, RuntimeLimitError, assertGraphWithinLimits, assertComponentsWithinLimits, assertTextWithinBytes, truncateText, assertObjectDepth, } from './runtime-limits';
+export type { IdentityProvider, UserIdentity, LoginCredentials, LoginResult, AuthErrorDetails, AuthChangeCallback, } from './IdentityProvider';
+export { createDefaultIdentityProvider, DefaultIdentityProvider } from './identity-provider-default';
+export type { DefaultIdentityProviderOptions } from './identity-provider-default';
+export { DEFAULT_KEYMAP, mergeKeymap, findKeyBinding, formatKeyBinding, } from './keymap';
+export type { KeyBinding } from './keymap';
+export { createLocalGlobalSearch } from './global-search';
+export type { GlobalSearchResult, GlobalSearchProvider, } from './global-search';
+export { parsePayloadToKvRows, serializeKvRowsToJson, isValidPayloadJson, } from './payload-kv';
+export type { PayloadKvRow } from './payload-kv';

package/dist/core/keymap.d.ts

@@ -0,0 +1,10 @@
+export interface KeyBinding {
+    key: string;
+    action: string;
+    scope?: 'canvas' | 'document' | 'editor';
+    when?: string;
+}
+export declare const DEFAULT_KEYMAP: readonly KeyBinding[];
+export declare function mergeKeymap(base: readonly KeyBinding[], overrides: readonly KeyBinding[]): KeyBinding[];
+export declare function findKeyBinding(keymap: readonly KeyBinding[], key: string, scope: string): KeyBinding | undefined;
+export declare function formatKeyBinding(binding: KeyBinding): string;

package/dist/core/payload-kv.d.ts

@@ -0,0 +1,7 @@
+export interface PayloadKvRow {
+    key: string;
+    value: string;
+}
+export declare function parsePayloadToKvRows(json: string): PayloadKvRow[] | null;
+export declare function serializeKvRowsToJson(rows: PayloadKvRow[]): string;
+export declare function isValidPayloadJson(json: string): boolean;

package/dist/core/rule-chain-versions.d.ts

@@ -0,0 +1,143 @@
+import type { RuleChainData } from '../types/rule-chain';
+export interface RuleChainVersion {
+    id: string;
+    seq?: number;
+    ts?: number | string;
+    source?: string;
+    nodeCount?: number;
+    dslSize?: number;
+    [key: string]: unknown;
+}
+export interface RuleChainVersionDetail extends RuleChainVersion {
+    dsl: RuleChainData;
+}
+export interface RuleChainVersionPage {
+    items: RuleChainVersion[];
+    total: number | null;
+    page: number;
+    pageSize: number;
+}
+export interface RuleChainVersionsFetcher {
+    getRuleVersions(chainId: string, page: number, size: number, signal?: AbortSignal): Promise<unknown>;
+    getRuleVersion(chainId: string, versionId: string, signal?: AbortSignal): Promise<unknown>;
+    rollbackRuleVersion(chainId: string, versionId: string, signal?: AbortSignal): Promise<unknown>;
+    getContent(chainId: string, signal?: AbortSignal): Promise<unknown>;
+}
+export type VersionErrorCode = 'invalid-response' | 'pagination-stalled' | 'confirmation-required' | 'draft-changed' | 'readonly';
+export declare class RuleChainVersionsError extends Error {
+    readonly code: VersionErrorCode;
+    constructor(code: VersionErrorCode, message: string);
+}
+export declare function normalizeRuleChainVersion(value: unknown): RuleChainVersion;
+export declare function normalizeRuleChainVersionPage(raw: unknown, page?: number, size?: number): RuleChainVersionPage;
+export declare function parseVersionRuleChain(raw: unknown, chainId?: string): RuleChainData;
+export declare function normalizeRuleChainVersionDetail(raw: unknown, chainId: string, versionId: string): RuleChainVersionDetail;
+export type AnalysisDiffKind = 'added' | 'removed' | 'changed';
+export interface JsonPathDiff {
+    path: string;
+    kind: AnalysisDiffKind;
+    before: unknown;
+    after: unknown;
+    a?: string;
+    b?: string;
+}
+export declare function stableAnalysisJson(value: unknown): string;
+export declare function diffJsonPaths(before: unknown, after: unknown, prefix?: string): JsonPathDiff[];
+export interface ChainNodeDiff {
+    id: string;
+    key: string;
+    label: string;
+    type: string;
+    kind: AnalysisDiffKind;
+    fields: string[];
+    configPaths: JsonPathDiff[];
+    changes: JsonPathDiff[];
+}
+export interface ChainEdgeDiff {
+    key: string;
+    from: string;
+    to: string;
+    label: string;
+    kind: AnalysisDiffKind;
+    changes: JsonPathDiff[];
+}
+export interface ChainVersionDiff {
+    nodes: ChainNodeDiff[];
+    edges: ChainEdgeDiff[];
+    chain: JsonPathDiff[];
+    summary: {
+        nodeAdded: number;
+        nodeRemoved: number;
+        nodeChanged: number;
+        edgeAdded: number;
+        edgeRemoved: number;
+        edgeChanged: number;
+        identical: boolean;
+    };
+}
+export declare function diffChains(older: unknown, newer: unknown): ChainVersionDiff;
+export declare function awaitVersionRequest<T>(operation: () => T | PromiseLike<T>, signal: AbortSignal): Promise<T>;
+export type VersionHistoryPhase = 'idle' | 'loading' | 'loading-more' | 'detail' | 'comparing' | 'confirming' | 'rolling-back' | 'refreshing';
+export interface VersionRollbackResult {
+    chainId: string;
+    version: RuleChainVersion;
+    response: unknown;
+    content: RuleChainData;
+    versions: RuleChainVersionPage;
+}
+export interface VersionRollbackConfirmation {
+    kind: 'rollback' | 'discard-dirty';
+    chainId: string;
+    version: RuleChainVersion;
+    signal: AbortSignal;
+}
+export interface RuleChainVersionsState {
+    chainId: string;
+    phase: VersionHistoryPhase;
+    items: readonly RuleChainVersion[];
+    total: number | null;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+    showDrafts: boolean;
+    selection: readonly string[];
+    detail: RuleChainVersionDetail | null;
+    comparison: {
+        older: RuleChainVersion;
+        newer: RuleChainVersion;
+        diff: ChainVersionDiff;
+    } | null;
+    error: {
+        operation: VersionHistoryPhase;
+        cause: unknown;
+        committed: boolean;
+    } | null;
+    pendingRollback: boolean;
+    lastRollback: VersionRollbackResult | null;
+}
+export interface RuleChainVersionsControllerOptions {
+    fetcher: RuleChainVersionsFetcher;
+    chainId?: string;
+    pageSize?: number;
+    isDirty: () => boolean;
+    canRollback?: () => boolean;
+    getDraftRevision?: () => unknown;
+    confirm: (request: VersionRollbackConfirmation) => boolean | Promise<boolean>;
+    onRolledBack?: (result: VersionRollbackResult, signal: AbortSignal) => void | Promise<void>;
+}
+export interface RuleChainVersionsController {
+    getState(): Readonly<RuleChainVersionsState>;
+    subscribe(listener: (state: Readonly<RuleChainVersionsState>) => void): () => void;
+    setChain(chainId: string): Promise<boolean>;
+    reload(): Promise<boolean>;
+    loadMore(): Promise<boolean>;
+    setShowDrafts(value: boolean): void;
+    select(versionId: string, selected: boolean): void;
+    inspect(versionId: string): Promise<boolean>;
+    compareSelected(): Promise<boolean>;
+    rollback(versionId: string): Promise<boolean>;
+    retryReadback(): Promise<boolean>;
+    cancel(): void;
+    destroy(): void;
+}
+export declare function createRuleChainVersionsController(options: RuleChainVersionsControllerOptions): RuleChainVersionsController;

package/dist/core/run-analysis.d.ts

@@ -0,0 +1,126 @@
+import { type JsonPathDiff } from './rule-chain-versions';
+export interface RunNodeLog {
+    nodeId?: string;
+    inMsg?: unknown;
+    outMsg?: unknown;
+    startTs?: number | string | null;
+    endTs?: number | string | null;
+    err?: unknown;
+    relationType?: string;
+    [key: string]: unknown;
+}
+export interface RunAnalysisRecord {
+    id?: string;
+    chainId?: string;
+    level?: string;
+    logs?: readonly RunNodeLog[];
+    success?: boolean;
+    durationMs?: number;
+    errorMsg?: string;
+    msgType?: string;
+    msgData?: unknown;
+    startTs?: number | string | null;
+    [key: string]: unknown;
+}
+export interface RunLogOccurrence {
+    key: string;
+    nodeId: string;
+    occurrence: number;
+    index: number;
+    log: RunNodeLog;
+}
+export declare function getRunNodeTiming(log: RunNodeLog): {
+    startTs: number | null;
+    endTs: number | null;
+    durationMs: number | null;
+    invalid: boolean;
+};
+export declare function runLogOccurrences(logs?: readonly RunNodeLog[]): RunLogOccurrence[];
+export interface RunWaterfallRow extends RunLogOccurrence {
+    label: string;
+    startTs: number;
+    endTs: number | null;
+    offsetMs: number;
+    durationMs: number | null;
+    observedMs: number;
+    unfinished: boolean;
+    invalidTiming: boolean;
+    err: string;
+    isSlowest: boolean;
+    left: number;
+    width: number;
+}
+export interface RunWaterfall {
+    rows: RunWaterfallRow[];
+    startTs: number | null;
+    spanMs: number;
+    scaleMs: number;
+    omittedCount: number;
+    slowest: RunWaterfallRow | null;
+    ticks: {
+        pct: number;
+        offsetMs: number;
+    }[];
+}
+export declare function buildRunWaterfall(logs?: readonly RunNodeLog[], nodeNames?: Readonly<Record<string, string>>, options?: {
+    scaleMs?: number;
+    observedUntil?: number;
+}): RunWaterfall;
+export declare function normalizeRunMessage(message: unknown): unknown;
+export declare function runPairKey(record: RunAnalysisRecord | null | undefined): string;
+export declare function nodeMsgDiff(a?: RunNodeLog | null, b?: RunNodeLog | null): {
+    inDiff: JsonPathDiff[];
+    outDiff: JsonPathDiff[];
+};
+export type RunComparisonStatus = 'same' | 'diverge' | 'error' | 'only-a' | 'only-b' | 'unknown';
+export interface RunComparisonRow {
+    key: string;
+    nodeId: string;
+    occurrence: number;
+    status: RunComparisonStatus;
+    downstream: boolean;
+    orderChanged: boolean;
+    aDur: number | null;
+    bDur: number | null;
+    aErr: string;
+    bErr: string;
+    aRel: string;
+    bRel: string;
+    a?: RunNodeLog;
+    b?: RunNodeLog;
+}
+export interface RunComparison {
+    level: 'detail' | 'mixed' | 'summary';
+    pair: {
+        same: boolean | null;
+        confidence: 'input' | 'summary';
+        keyA: string;
+        keyB: string;
+    };
+    chain: {
+        successA: boolean | null;
+        successB: boolean | null;
+        successDiff: boolean;
+        errA: string;
+        errB: string;
+        durationA: number | null;
+        durationB: number | null;
+        msgTypeA: string;
+        msgTypeB: string;
+        outDiff: JsonPathDiff[];
+    };
+    timeline: RunComparisonRow[];
+    firstDivergence: {
+        key: string;
+        nodeId: string;
+    } | null;
+    counts: {
+        same: number;
+        diverge: number;
+        error: number;
+        onlyA: number;
+        onlyB: number;
+        unknown: number;
+    };
+}
+export declare function diffRuns(eventA: RunAnalysisRecord, eventB: RunAnalysisRecord): RunComparison;

package/dist/core/runtime-field-dictionary.d.ts

@@ -34,6 +34,7 @@ export interface RuntimeFieldCompletionItem {
 export interface RuntimeFieldSlot {
     paths: RuntimeFieldPath[];
     ts: number;
+    msg?: RuntimeFieldMessage;
 }
 export interface RuntimeNodeFieldEntry {
     in?: RuntimeFieldSlot;
@@ -45,6 +46,7 @@ export interface RuntimeFieldDictionaryOptions {
     sampleLength?: number;
 }
 export type RuntimeFieldDictionaryListener = () => void;
+export declare function isSensitiveRuntimeFieldName(name: string): boolean;
 export declare function extractRuntimeFieldPaths(message: RuntimeFieldMessage | null | undefined, options?: RuntimeFieldDictionaryOptions): RuntimeFieldPath[];
 export declare class RuntimeFieldDictionary {
     private readonly options;
@@ -60,6 +62,7 @@ export declare class RuntimeFieldDictionary {
     ingest(event: RuntimeFieldEvent | null | undefined, fallbackChainId?: unknown): boolean;
     getNodePaths(nodeId: unknown): RuntimeFieldPath[];
     getUpstreamPaths(nodeId: unknown, connections: RuntimeFieldConnection[] | undefined): RuntimeFieldPath[];
+    getUpstreamMessage(nodeId: unknown, connections?: RuntimeFieldConnection[]): RuntimeFieldMessage | null;
     clear(): void;
     subscribe(listener: RuntimeFieldDictionaryListener): () => void;
     destroy(): void;

package/dist/core/save-conflict.d.ts

@@ -1,4 +1,5 @@
 import type { RuleChainData } from '../types/rule-chain';
+export declare function isCompleteRuleChainSnapshot(value: unknown): value is RuleChainData;
 export declare function normalizeRuleChainSaveSnapshot(data: unknown): unknown;
 export declare function createRuleChainSaveFingerprint(data: unknown): string;
 export declare function hasRuleChainSaveConflict(remote: unknown, baseline: RuleChainData | unknown): boolean;

package/dist/core/server-status.d.ts

@@ -27,6 +27,7 @@ export declare class ServerStatusStore {
     subscribe(listener: (state: Readonly<ServerStatusState>, previousState: Readonly<ServerStatusState>) => void): () => void;
     setServerUrl(baseUrl: string, wsUrl?: string): void;
     setServerStatus(status: ServerStatus, details?: Partial<ServerStatusState>): void;
+    markApiSuccess(): void;
     recordHttpStatus(statusCode: number, message?: string): ServerStatus;
     recordWebSocketStatus(eventStatus: ServerWsEventStatus, closeCode?: number | null, message?: string): ServerStatus;
     setReconnectAttempt(attempt: number): void;