@huanban/rulego-editor-core 1.3.18 → 1.4.0

package/dist/core/editor-dock.d.ts

@@ -0,0 +1,100 @@
+export type EditorDockId = 'left' | 'right' | 'bottom' | 'ai';
+export type EditorWidthDockId = Exclude<EditorDockId, 'bottom'>;
+export interface EditorWidthDockState {
+    visible: boolean;
+    width: number;
+}
+export interface EditorHeightDockState {
+    visible: boolean;
+    height: number;
+}
+export interface EditorDockState extends Record<string, unknown> {
+    left: EditorWidthDockState;
+    right: EditorWidthDockState;
+    bottom: EditorHeightDockState;
+    ai: EditorWidthDockState;
+}
+export interface EditorDockBounds {
+    widthMin?: number;
+    widthMax?: number;
+    heightMin?: number;
+    heightMax?: number;
+}
+export type EditorDockPersistenceState = Partial<{
+    [K in EditorDockId]: K extends 'bottom' ? Partial<EditorHeightDockState> : Partial<EditorWidthDockState>;
+}>;
+export type EditorPersistenceScope = 'dock' | 'panel' | 'chat' | 'recent-components' | 'test-cases' | 'explorer';
+export interface EditorPersistenceAdapter {
+    getItem(key: string): string | null | undefined;
+    setItem(key: string, value: string): void;
+    removeItem?(key: string): void;
+}
+export interface EditorPersistenceNamespace {
+    host: string;
+    editorInstance: string;
+    version: string | number;
+}
+export interface EditorPersistenceMigrationContext {
+    scope: EditorPersistenceScope;
+    namespace: Readonly<EditorPersistenceNamespace>;
+    fromVersion: string;
+    toVersion: string;
+    key: string;
+}
+export interface EditorStatePersistenceOptions<TState = unknown> {
+    adapter: EditorPersistenceAdapter;
+    namespace: EditorPersistenceNamespace;
+    migrateFromVersions?: ReadonlyArray<string | number>;
+    migrate?: (state: unknown, context: EditorPersistenceMigrationContext) => TState | null | undefined;
+}
+export type EditorChatHistoryMode = 'assistant' | 'run' | 'component';
+export interface EditorChatHistoryPersistenceOptions {
+    adapter: EditorPersistenceAdapter;
+    namespace: EditorPersistenceNamespace;
+    chainId: string;
+    mode: EditorChatHistoryMode;
+}
+export interface EditorDockOptions {
+    initial?: Partial<{
+        [K in EditorDockId]: K extends 'bottom' ? Partial<EditorHeightDockState> : Partial<EditorWidthDockState>;
+    }>;
+    bounds?: EditorDockBounds;
+    persistence?: EditorStatePersistenceOptions<EditorDockPersistenceState>;
+}
+type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+export declare function buildEditorPersistenceKey(scope: EditorPersistenceScope, namespace?: EditorPersistenceNamespace): string | null;
+export declare function buildEditorChatHistoryKey(options?: Pick<EditorChatHistoryPersistenceOptions, 'namespace' | 'chainId' | 'mode'>): string | null;
+export declare function readEditorChatHistory(options: EditorChatHistoryPersistenceOptions): unknown[];
+export declare function writeEditorChatHistory(options: EditorChatHistoryPersistenceOptions, messages: readonly unknown[]): boolean;
+export declare function clearEditorChatHistory(options: EditorChatHistoryPersistenceOptions): boolean;
+export interface EditorPersistenceController<TState> {
+    readonly key: string;
+    readonly restoredState: TState | null;
+    readonly migrated: boolean;
+    save(state: TState): void;
+    destroy(): void;
+}
+export declare function createEditorPersistenceController<TState>(scope: EditorPersistenceScope, options: EditorStatePersistenceOptions<TState> | undefined, normalizeState: (value: unknown) => TState | null): EditorPersistenceController<TState> | null;
+export declare class EditorDockStore {
+    private readonly store;
+    private readonly bounds;
+    private readonly persistence;
+    private readonly transientWidthBaselines;
+    private unsubscribePersistence;
+    private destroyed;
+    constructor(options?: EditorDockOptions);
+    private toPersistenceState;
+    getDockState(): EditorDockState;
+    subscribe(listener: (state: Readonly<EditorDockState>, previousState: Readonly<EditorDockState>) => void): () => void;
+    setDockVisibility(dock: EditorDockId, visible: boolean): boolean;
+    setDockWidth(dock: EditorDockId, value: number): boolean;
+    setDockHeight(dock: EditorDockId, value: number): boolean;
+    beginTransientDockWidth(dock: EditorWidthDockId, minimumWidth: number): boolean;
+    restoreTransientDockWidth(dock: EditorWidthDockId): boolean;
+    resetDockState(): EditorDockState | null;
+    destroy(): void;
+}
+export declare const DEFAULT_EDITOR_DOCK_STATE: DeepReadonly<EditorDockState>;
+export {};

package/dist/core/editor-panel.d.ts

@@ -0,0 +1,68 @@
+import type { EditorDockId, EditorDockStore, EditorStatePersistenceOptions } from './editor-dock';
+export type EditorPanelId = 'explorer' | 'components' | 'info' | 'node-config' | 'node-docs' | 'problems' | 'run-debug' | 'run-logs' | 'send' | 'ai';
+export interface EditorPanelDefinition {
+    id: string;
+    dock: EditorDockId;
+    title?: string;
+    icon?: string;
+    order?: number;
+    closeable?: boolean;
+    visible?: boolean;
+    defaultExpanded?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface EditorPanelState extends Record<string, unknown> {
+    panels: EditorPanelDefinition[];
+    openPanelIds: string[];
+    activeByDock: Partial<Record<EditorDockId, string | null>>;
+    expandedById?: Record<string, boolean>;
+}
+export interface EditorPanelPersistenceState {
+    openPanelIds: string[];
+    activeByDock: Partial<Record<EditorDockId, string | null>>;
+    expandedById?: Record<string, boolean>;
+}
+export interface EditorPanelRegistryOptions {
+    panels?: ReadonlyArray<EditorPanelDefinition>;
+    initiallyOpen?: string[];
+    activeByDock?: Partial<Record<EditorDockId, string | null>>;
+    dockStore?: EditorDockStore;
+    persistence?: EditorStatePersistenceOptions<EditorPanelPersistenceState>;
+    syncDockVisibility?: boolean;
+}
+type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+export declare const DEFAULT_EDITOR_PANELS: ReadonlyArray<DeepReadonly<EditorPanelDefinition>>;
+export declare const DEFAULT_EDITOR_OPEN_PANEL_IDS: readonly ["components"];
+export declare const DEFAULT_NODE_CONFIG_DOCK_WIDTH = 560;
+export declare class EditorPanelRegistry {
+    private readonly store;
+    private readonly dockStore?;
+    private readonly persistence;
+    private unsubscribePersistence;
+    private destroyed;
+    constructor(options?: EditorPanelRegistryOptions);
+    getState(): Readonly<EditorPanelState>;
+    getPanels(dock?: EditorDockId): EditorPanelDefinition[];
+    getPanel(id: string): EditorPanelDefinition | null;
+    syncDockVisibility(): void;
+    subscribe(listener: (state: Readonly<EditorPanelState>, previousState: Readonly<EditorPanelState>) => void): () => void;
+    register(panel: EditorPanelDefinition, options?: {
+        open?: boolean;
+        activate?: boolean;
+    }): boolean;
+    unregister(id: string): boolean;
+    openPanel(id: string, activate?: boolean): boolean;
+    openNodeConfigPanel(minimumWidth?: number): boolean;
+    restoreNodeConfigPanelWidth(): boolean;
+    closePanel(id: string): boolean;
+    activatePanel(id: string): boolean;
+    setPanelExpanded(id: string, expanded: boolean): boolean;
+    togglePanelExpanded(id: string): boolean;
+    isPanelExpanded(id: string): boolean;
+    isOpen(id: string): boolean;
+    getActivePanel(dock: EditorDockId): EditorPanelDefinition | null;
+    destroy(): void;
+}
+export {};

package/dist/core/explorer-tree.d.ts

@@ -0,0 +1,27 @@
+import type { WorkflowItem } from '../api/types';
+export type ExplorerTreeNodeKind = 'section' | 'category' | 'chain';
+export interface ExplorerTreeNode {
+    key: string;
+    label: string;
+    kind: ExplorerTreeNodeKind;
+    count?: number;
+    path?: string;
+    chain?: WorkflowItem;
+    children?: ExplorerTreeNode[];
+}
+export interface ExplorerTreeLabels {
+    root: string;
+    sub: string;
+    uncategorized: string;
+}
+export interface ExplorerTreeOptions {
+    keyword?: string;
+    labels?: Partial<ExplorerTreeLabels>;
+}
+export declare const EXPLORER_SECTION_ROOT = "section:root";
+export declare const EXPLORER_SECTION_SUB = "section:sub";
+export declare function buildExplorerTree(workflows?: readonly WorkflowItem[], options?: ExplorerTreeOptions): ExplorerTreeNode[];
+export declare function expandedExplorerKeys(tree?: readonly ExplorerTreeNode[]): string[];
+export declare function explorerAncestorKeys(tree: readonly ExplorerTreeNode[] | undefined, targetKey: string): string[];
+export declare function normalizeExplorerExpandedKeys(tree: readonly ExplorerTreeNode[], keys: readonly string[]): string[];
+export declare function findExplorerNode(tree: readonly ExplorerTreeNode[] | undefined, key: string): ExplorerTreeNode | null;

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

@@ -0,0 +1,32 @@
+import type { ComponentDefinition, ComponentField, FieldDependency } from '../types/component';
+export interface ResolveComponentFieldsContext {
+    configuration?: Record<string, unknown>;
+    getFieldsByType?: (type: string) => ComponentField[] | undefined;
+}
+export interface FieldAttachmentEntry {
+    target: string;
+    field: ComponentField;
+    mode: 'drawer' | 'popover';
+}
+export type MapValueMode = 'string' | 'json';
+export interface FieldValidationError {
+    field: string;
+    message: string;
+}
+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 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 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 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/foundation-tokens.d.ts

@@ -0,0 +1,38 @@
+export declare const EDITOR_FOUNDATION_TOKEN_VALUES: Readonly<{
+    readonly 'font-family': "system-ui, -apple-system, BlinkMacSystemFont, \"Segoe UI\", \"PingFang SC\", \"Hiragino Sans GB\", \"Microsoft YaHei\", sans-serif";
+    readonly 'font-mono': "ui-monospace, \"SFMono-Regular\", \"Cascadia Code\", Menlo, Monaco, Consolas, monospace";
+    readonly 'font-size-xs': "11px";
+    readonly 'font-size-sm': "12px";
+    readonly 'font-size-base': "13px";
+    readonly 'font-size-lg': "14px";
+    readonly 'font-size-xl': "16px";
+    readonly 'font-size-2xl': "18px";
+    readonly 'font-size-3xl': "20px";
+    readonly 'icon-size': "16px";
+    readonly 'icon-size-lg': "20px";
+    readonly 'icon-size-xl': "24px";
+    readonly 'leading-tight': "1.45";
+    readonly 'leading-relaxed': "1.65";
+    readonly 'weight-normal': "400";
+    readonly 'weight-medium': "500";
+    readonly 'weight-semibold': "600";
+    readonly 'weight-bold': "700";
+    readonly 'space-3xs': "2px";
+    readonly 'space-2xs': "4px";
+    readonly 'space-xs': "6px";
+    readonly 'space-sm': "8px";
+    readonly 'space-md': "12px";
+    readonly 'space-lg': "16px";
+    readonly 'space-xl': "24px";
+    readonly 'space-2xl': "32px";
+    readonly 'space-3xl': "48px";
+    readonly 'space-tight': "6px";
+    readonly 'space-panel': "12px";
+    readonly 'duration-fast': "100ms";
+    readonly duration: "160ms";
+    readonly 'duration-slow': "240ms";
+    readonly 'ease-out': "cubic-bezier(0.25, 1, 0.5, 1)";
+    readonly 'ease-expo': "cubic-bezier(0.16, 1, 0.3, 1)";
+}>;
+export type EditorFoundationTokenPrefix = '--hb' | '--rg';
+export declare function createEditorFoundationVariables(prefix: EditorFoundationTokenPrefix): Record<string, string>;

package/dist/core/graph-operations.d.ts

@@ -0,0 +1,34 @@
+import type { LFEdgeData, LFGraphData, LFNodeData } from './DataAdapter';
+export type AlignMode = 'left' | 'right' | 'top' | 'bottom' | 'horizontal-center' | 'vertical-center';
+export type DistributeMode = 'horizontal' | 'vertical';
+export declare function alignGraphNodes(graph: LFGraphData, nodeIds: string[], mode: AlignMode): LFGraphData;
+export declare function distributeGraphNodes(graph: LFGraphData, nodeIds: string[], mode: DistributeMode): LFGraphData;
+export declare function snapGraphNodesToGrid(graph: LFGraphData, nodeIds: string[], gridSize?: number): LFGraphData;
+export declare function selectConnectedNodeIds(graph: LFGraphData, startIds: string[], direction?: 'upstream' | 'downstream' | 'both'): string[];
+export interface CloneGraphSelectionOptions {
+    offsetX?: number;
+    offsetY?: number;
+    idGenerator: (kind: 'node' | 'edge', sourceId: string) => string;
+    transformNode?: (node: LFNodeData, source: LFNodeData) => LFNodeData;
+}
+export interface ClonedGraphSelection {
+    nodes: LFNodeData[];
+    edges: LFEdgeData[];
+    nodeIdMap: Record<string, string>;
+}
+export interface InsertGraphNodeOnEdgeOptions {
+    node: LFNodeData;
+    firstEdgeId: string;
+    secondEdgeId: string;
+    firstRelationType?: string;
+    secondRelationType?: string;
+}
+export interface InsertGraphNodeOnEdgeResult {
+    graph: LFGraphData;
+    originalEdge: LFEdgeData;
+    insertedNode: LFNodeData;
+    insertedEdges: [LFEdgeData, LFEdgeData];
+}
+export declare function insertGraphNodeOnEdge(graph: LFGraphData, edgeId: string, options: InsertGraphNodeOnEdgeOptions): InsertGraphNodeOnEdgeResult | null;
+export declare function reserveUniqueGraphElementId(candidate: unknown, usedIds: Set<string>, fallback?: string): string;
+export declare function cloneGraphSelection(graph: LFGraphData, nodeIds: string[], options: CloneGraphSelectionOptions): ClonedGraphSelection;

package/dist/core/hover-tools.d.ts

@@ -0,0 +1,26 @@
+export interface EditorHoverToolPosition {
+    x: number;
+    y: number;
+    flipDown?: boolean;
+}
+export interface EditorHoverToolTarget extends EditorHoverToolPosition {
+    targetId: string;
+    visible?: boolean;
+}
+export interface EditorNodeRunTarget {
+    type?: unknown;
+    nodeType?: unknown;
+    properties?: {
+        model?: {
+            type?: unknown;
+            nodeType?: unknown;
+        } | null;
+        view?: {
+            type?: unknown;
+            nodeType?: unknown;
+        } | null;
+    } | null;
+}
+export declare function isEditorNodeRunTarget(target: EditorNodeRunTarget | string | null | undefined): boolean;
+export type EditorNodeHoverAction = 'edit' | 'copy' | 'delete' | 'run-from' | 'run-only';
+export type EditorEdgeHoverAction = 'insert-node' | 'delete';

package/dist/core/index.d.ts

@@ -1,20 +1,7 @@
-/**
- * @file core/index.ts
- * @description 核心模块统一导出入口
- *
- * 所有核心子系统均从此处导出:
- * - StateStore: 框架无关的响应式状态容器
- * - EventBus: 类型安全的事件总线
- * - DataAdapter: RuleGo ↔ LogicFlow 数据格式转换
- * - ComponentRegistry: 组件注册表
- * - HistoryManager: 撤销/重做管理
- * - ValidationEngine: 图验证引擎
- * - ThemeManager: 主题切换管理
- * - I18nManager: 国际化管理
- * - EditorCore: 核心引擎 (整合以上所有子系统)
- */
 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 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';
 export { ComponentRegistry } from './ComponentRegistry';
@@ -28,9 +15,74 @@ export type { ThemeVariables, ThemeDefinition } from './ThemeManager';
 export { I18nManager, i18nText } from './I18nManager';
 export type { LocaleMessages, TranslationSource } from './I18nManager';
 export { EditorCore } from './EditorCore';
+export { getEditorToolbarIconSvg, isEditorToolbarIconName, renderEditorToolbarIcon } from './toolbar-icons';
+export type { EditorToolbarIconName } from './toolbar-icons';
+export { clampContextMenuPosition, resolveContextSubmenuPosition, } from './context-menu-position';
+export type { ContextMenuPosition, ContextMenuRect, ContextMenuSize, ContextMenuViewport, } from './context-menu-position';
+export { extractRunMessageFields, extractRunMessageTypes, inferRunInput, extractMsgFields, extractMsgTypes, } from './infer-run-input';
+export type { RunInputInference } from './infer-run-input';
+export { normalizeKeyValueSelection, removeKeyValueEntriesAtIndexes, } from './key-value-editor';
+export type { KeyValueEditorEntry } from './key-value-editor';
+export { createDebugPanelRequestSnapshot, isDebugPanelRequestCurrent, } from './debug-panel';
+export type { DebugPanelRequestSnapshot } from './debug-panel';
+export { getRuleChainErrorTexts, isRuleChainNotDeployedError, resolveRuleChainDeployState, } from './run-guard';
+export type { ResolveRuleChainDeployStateOptions, RuleChainDeployState, } from './run-guard';
+export { ActionRegistry } from './ActionRegistry';
+export type { EditorAction, EditorActionContext, EditorActionRuntime, EditorActionSource, EditorSelectionSnapshot, EditorShortcut, } from './ActionRegistry';
+export { FieldCapabilityRegistry } from './FieldCapabilityRegistry';
+export type { FieldCapabilityContext, FieldCapabilityHandler } from './FieldCapabilityRegistry';
+export { OptionSourceRegistry, buildOptionSourceRequestKey } from './OptionSourceRegistry';
+export type { OptionSourceContext, OptionSourceResolveContext, OptionSourceResolver } from './OptionSourceRegistry';
+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 { 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 type { ComponentPaletteBuildOptions, ComponentPaletteGroup, ComponentPaletteSubgroup } from './component-palette';
+export { ComponentDocService } from './ComponentDocService';
+export type { ComponentDoc, ComponentDocMeta, ComponentDocProvider } from './ComponentDocService';
+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';
+export { ExplorerTreeStore } from './ExplorerTreeStore';
+export type { ExplorerTreePersistenceState, ExplorerTreeStoreOptions, ExplorerTreeState, } from './ExplorerTreeStore';
+export { SIMPLE_ARRAY_DELIMITER, mergeSimpleArrayValues, normalizeSimpleArrayValues, parseSimpleArrayInput, } from './simple-array';
+export { EditorWorkspace } from './EditorWorkspace';
+export type { EditorWorkspaceTab, EditorWorkspaceState, OpenWorkspaceTabInput, WorkspaceCloseDecision, WorkspaceCloseResultReason, WorkspaceSaveResponse, WorkspaceSaveOutcome, WorkspaceSaveHandlerResult, WorkspaceSaveHandler, CloseWorkspaceTabOptions, CloseWorkspaceTabDecisionOptions, CloseWorkspaceTabResult, WorkspaceConflictResolution, WorkspaceConflictResult, WorkspaceListener, } from './EditorWorkspace';
+export { getEditorWorkspaceTabActions, getWorkspaceTabLifecycleState, isWorkspaceTabDisabled, isWorkspaceTabPinned, } from './workspace-tab-actions';
+export type { EditorWorkspaceTabAction, EditorWorkspaceTabActionDescriptor, EditorWorkspaceTabLifecycleState, } from './workspace-tab-actions';
+export { createRuleChainSaveFingerprint, hasRuleChainSaveConflict, normalizeRuleChainSaveSnapshot, } from './save-conflict';
+export { EditorDockStore, DEFAULT_EDITOR_DOCK_STATE, buildEditorPersistenceKey, buildEditorChatHistoryKey, readEditorChatHistory, writeEditorChatHistory, clearEditorChatHistory, } from './editor-dock';
+export type { EditorDockId, EditorWidthDockId, EditorWidthDockState, EditorHeightDockState, EditorDockState, EditorDockBounds, EditorDockPersistenceState, EditorDockOptions, EditorPersistenceScope, EditorPersistenceAdapter, EditorPersistenceNamespace, EditorPersistenceMigrationContext, EditorStatePersistenceOptions, EditorChatHistoryMode, EditorChatHistoryPersistenceOptions, } from './editor-dock';
+export { EditorPanelRegistry, DEFAULT_EDITOR_PANELS, DEFAULT_EDITOR_OPEN_PANEL_IDS, DEFAULT_NODE_CONFIG_DOCK_WIDTH, } from './editor-panel';
+export type { EditorPanelId, EditorPanelDefinition, EditorPanelState, EditorPanelPersistenceState, EditorPanelRegistryOptions, } from './editor-panel';
+export { ServerStatusStore, deriveWsUrl } from './server-status';
+export type { ServerStatus, ServerApiStatus, ServerWsStatus, ServerWsEventStatus, ServerStatusState, ServerStatusOptions, } from './server-status';
+export { ConnectionStatusController, ConnectionStatusStore, normalizeConnectionStatusMap, resolveConnectionStatusView, } from './connection-status';
+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 { 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';
+export type { VirtualWindow, VirtualWindowOptions } from './virtual-window';
+export { RecentComponentsStore, RECENT_COMPONENTS_DEFAULTS } from './recent-components';
+export type { RecentComponentEntry, RecentComponentsPersistenceOptions, RecentComponentsOptions, RecentComponentsState, } from './recent-components';
+export { EditorTestCasesStore } from './test-cases';
+export type { EditorTestCasePayload, EditorTestCaseEntry, EditorTestCasesPersistenceOptions, EditorTestCasesOptions, EditorTestCasesResult, } from './test-cases';
+export { createEmptyTableRow, coerceTableCellValue, decodeTableRowsForEditing, encodeTableRowsForStorage, findDuplicateRowValues, generatePointRows, getPointTableImportDecision, getTableColumns, getTableDetailFields, isPointTableFields, normalizeTableRows, paginateTableRows, parseCsvTable, serializeCsvTable, } from './table-protocol';
+export type { PointGenerationOptions, PointTableImportDecision, TablePage, TableRow } from './table-protocol';
+export { cronPresetToRuleGoCron, nextRuleGoCronRuns, normalizeRuleGoCron, ruleGoCronToPreset, validateRuleGoCron, } from './cron-schedule';
+export type { RuleGoCronBuildResult, RuleGoCronError, RuleGoCronErrorCode, RuleGoCronNextRunsOptions, RuleGoCronNextRunsResult, RuleGoCronPreset, RuleGoCronPresetParseResult, RuleGoCronValidationResult, } from './cron-schedule';
 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 { RUNTIME_LIMITS, RuntimeLimitError, assertGraphWithinLimits, assertComponentsWithinLimits, assertTextWithinBytes, truncateText, assertObjectDepth, } from './runtime-limits';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/infer-run-input.d.ts

@@ -0,0 +1,11 @@
+export interface RunInputInference {
+    msgType: string;
+    body: string;
+    msgTypes: string[];
+    fields: string[];
+}
+export declare function extractRunMessageFields(input: unknown): string[];
+export declare function extractRunMessageTypes(input: unknown): string[];
+export declare function inferRunInput(input: unknown): RunInputInference;
+export declare const extractMsgFields: typeof extractRunMessageFields;
+export declare const extractMsgTypes: typeof extractRunMessageTypes;

package/dist/core/key-value-editor.d.ts

@@ -0,0 +1,6 @@
+export interface KeyValueEditorEntry<T = string> {
+    key: string;
+    value: T;
+}
+export declare function normalizeKeyValueSelection(selection: Iterable<number>, length: number): number[];
+export declare function removeKeyValueEntriesAtIndexes<T>(entries: readonly KeyValueEditorEntry<T>[], selection: Iterable<number>): KeyValueEditorEntry<T>[];

package/dist/core/overlay-layers.d.ts

@@ -0,0 +1,28 @@
+export declare const EDITOR_OVERLAY_LAYERS: Readonly<{
+    readonly chrome: 10;
+    readonly localOverlay: 190;
+    readonly floating: 10000;
+    readonly drawerBackdrop: 10010;
+    readonly drawer: 10011;
+    readonly modalBackdrop: 10020;
+    readonly modal: 10021;
+    readonly attachment: 10030;
+    readonly optionPicker: 10040;
+    readonly confirmation: 10050;
+    readonly notification: 10060;
+}>;
+export type EditorOverlayLayerName = keyof typeof EDITOR_OVERLAY_LAYERS;
+export declare const EDITOR_OVERLAY_LAYER_CSS_VARIABLES: Readonly<{
+    chrome: string;
+    localOverlay: string;
+    floating: string;
+    drawerBackdrop: string;
+    drawer: string;
+    modalBackdrop: string;
+    modal: string;
+    attachment: string;
+    optionPicker: string;
+    confirmation: string;
+    notification: string;
+}>;
+export declare const EDITOR_OVERLAY_LAYER_CSS_TEXT: string;

package/dist/core/recent-components.d.ts

@@ -0,0 +1,51 @@
+import { type EditorPersistenceAdapter, type EditorPersistenceNamespace } from './editor-dock';
+export interface RecentComponentEntry {
+    count: number;
+    ts: number;
+}
+export interface RecentComponentsPersistenceOptions {
+    adapter: EditorPersistenceAdapter;
+    namespace: EditorPersistenceNamespace;
+}
+export interface RecentComponentsOptions {
+    persistence?: RecentComponentsPersistenceOptions;
+    maxEntries?: number;
+    topN?: number;
+    halfLifeDays?: number;
+    now?: () => number;
+}
+export interface RecentComponentsState {
+    entries: Record<string, RecentComponentEntry>;
+}
+export declare class RecentComponentsStore {
+    private readonly adapter?;
+    private readonly storageKey;
+    private readonly persistenceIdentity;
+    private readonly maxEntries;
+    private readonly topN;
+    private readonly halfLifeDays;
+    private readonly now;
+    private entries;
+    private listeners;
+    private destroyed;
+    constructor(options?: RecentComponentsOptions);
+    getState(): RecentComponentsState;
+    subscribe(listener: (state: RecentComponentsState) => void): () => void;
+    recordUse(type: string): {
+        persisted: boolean;
+        topTypes: string[];
+    };
+    getTopTypes(limit?: number): string[];
+    clear(): boolean;
+    destroy(): void;
+    private score;
+    private prune;
+    private read;
+    private write;
+    private emit;
+}
+export declare const RECENT_COMPONENTS_DEFAULTS: Readonly<{
+    maxEntries: 60;
+    topN: 8;
+    halfLifeDays: 14;
+}>;

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

@@ -0,0 +1,7 @@
+export type RuleChainDeployState = 'undeployed' | 'stopped' | 'running' | 'unknown';
+export interface ResolveRuleChainDeployStateOptions {
+    missingAsUnknown?: boolean;
+}
+export declare function resolveRuleChainDeployState(ruleChain: unknown, options?: ResolveRuleChainDeployStateOptions): RuleChainDeployState;
+export declare function getRuleChainErrorTexts(error: unknown): string[];
+export declare function isRuleChainNotDeployedError(error: unknown, chainId?: string): boolean;

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

@@ -0,0 +1,68 @@
+export declare const DEFAULT_RUNTIME_FIELD_MAX_PATHS = 300;
+export declare const DEFAULT_RUNTIME_FIELD_MAX_DEPTH = 6;
+export declare const DEFAULT_RUNTIME_FIELD_SAMPLE_LENGTH = 40;
+export interface RuntimeFieldPath {
+    path: string;
+    type: string;
+    sample: string;
+}
+export interface RuntimeFieldMessage {
+    data?: unknown;
+    dataType?: unknown;
+    metadata?: unknown;
+    type?: unknown;
+    [key: string]: unknown;
+}
+export interface RuntimeFieldEvent {
+    chainId?: unknown;
+    nodeId?: unknown;
+    flowType?: unknown;
+    msg?: RuntimeFieldMessage | null;
+    ts?: unknown;
+    [key: string]: unknown;
+}
+export interface RuntimeFieldConnection {
+    sourceNodeId?: unknown;
+    targetNodeId?: unknown;
+}
+export interface RuntimeFieldCompletionItem {
+    label?: string;
+    value?: string;
+    detail?: string;
+    type?: string;
+}
+export interface RuntimeFieldSlot {
+    paths: RuntimeFieldPath[];
+    ts: number;
+}
+export interface RuntimeNodeFieldEntry {
+    in?: RuntimeFieldSlot;
+    out?: RuntimeFieldSlot;
+}
+export interface RuntimeFieldDictionaryOptions {
+    maxPaths?: number;
+    maxDepth?: number;
+    sampleLength?: number;
+}
+export type RuntimeFieldDictionaryListener = () => void;
+export declare function extractRuntimeFieldPaths(message: RuntimeFieldMessage | null | undefined, options?: RuntimeFieldDictionaryOptions): RuntimeFieldPath[];
+export declare class RuntimeFieldDictionary {
+    private readonly options;
+    private readonly listeners;
+    private entries;
+    private activeChainId;
+    private version;
+    private destroyed;
+    constructor(options?: RuntimeFieldDictionaryOptions);
+    getChainId(): string;
+    getVersion(): number;
+    setChain(chainId: unknown): void;
+    ingest(event: RuntimeFieldEvent | null | undefined, fallbackChainId?: unknown): boolean;
+    getNodePaths(nodeId: unknown): RuntimeFieldPath[];
+    getUpstreamPaths(nodeId: unknown, connections: RuntimeFieldConnection[] | undefined): RuntimeFieldPath[];
+    clear(): void;
+    subscribe(listener: RuntimeFieldDictionaryListener): () => void;
+    destroy(): void;
+    private emitChange;
+}
+export declare function mergeRuntimeFieldCompletions(schemaItems: RuntimeFieldCompletionItem[] | undefined, runtimePaths: RuntimeFieldPath[] | undefined, observedLabel?: string): RuntimeFieldCompletionItem[];

package/dist/core/runtime-limits.d.ts

@@ -1,7 +1,3 @@
-/**
- * @file core/runtime-limits.ts
- * @description Shared size limits to keep imports, rendering, layout, debug, and storage bounded.
- */
 export declare const RUNTIME_LIMITS: {
     readonly maxImportBytes: number;
     readonly maxGraphNodes: 1000;
@@ -33,4 +29,3 @@ export declare function assertComponentsWithinLimits(components: unknown[]): voi
 export declare function assertTextWithinBytes(text: string, maxBytes: number, label: string): void;
 export declare function truncateText(value: unknown, maxChars: number): string;
 export declare function assertObjectDepth(value: unknown, maxDepth: number, label: string): void;
-//# sourceMappingURL=runtime-limits.d.ts.map

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

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