@huanban/rulego-editor-core 1.4.1 → 2.0.0

package/dist/standalone/editor-dialogs.d.ts

@@ -1,3 +1,4 @@
+import type { RuleChainData } from '../types/rule-chain';
 import { ApiProvider } from '../api/ApiProvider';
 import type { EditorTestCasesStore } from '../core/test-cases';
 export interface EditorContext {
@@ -9,6 +10,7 @@ export interface EditorContext {
     capabilities?: import('../core/editor-capabilities').EditorCapabilities;
     connectionStatus?: import('../core/connection-status').ConnectionStatusStore;
     rootEl?: HTMLElement;
+    _dialogProvider?: import('../core/DialogProvider').DialogProvider;
     _activeDrawerWrapper?: HTMLElement | null;
     _activeModalWrapper?: HTMLElement | null;
     components: any[];
@@ -18,6 +20,12 @@ export interface EditorContext {
     t(key: string, params?: Record<string, string>): string;
     exportData(): any;
     loadData(data: any): void;
+    openRuleChain?(data: string | RuleChainData): Promise<boolean>;
+    requestOpenRuleChain?(data: string | RuleChainData): Promise<boolean>;
+    getDraftFingerprint?(): string;
+    applyRuleChainDraft?(data: RuleChainData, expectedFingerprint?: string): boolean | Promise<boolean>;
+    _markSavedSnapshot?(data: RuleChainData): void;
+    _syncChainLifecycle?(action: 'start' | 'stop'): void;
     renderSidebar(): void;
     _escapeHtml(str: string): string;
     _closeDrawer(): void;
@@ -29,13 +37,27 @@ export interface EditorContext {
     acquireSharedConnectionStatuses?(): () => void;
 }
 export interface RunPanelOptions {
+    prompt?: string;
     fromNodeId?: string;
     onlyThisNode?: boolean;
     initialMode?: 'form' | 'chat';
     initialTab?: 'response' | 'resp_headers' | 'debug' | 'history' | 'integration';
     section?: string;
 }
-export type SettingsDialogTab = 'user' | 'setting' | 'ai' | 'skills';
+export type SettingsDialogTab = 'user' | 'setting' | 'interface' | 'ai' | 'skills' | 'globalConfig' | (string & {});
+export interface EditorSettingsPane {
+    id: string;
+    label: string | ((locale: string) => string);
+    mount(container: HTMLElement, context: {
+        editor: EditorContext;
+        signal: AbortSignal;
+        readOnly: boolean;
+    }): {
+        destroy(): void;
+        requestClose?(): boolean | Promise<boolean>;
+        refreshLocale?(): void;
+    };
+}
 export type ComponentManageDialogTab = 'installed' | 'market' | 'dsl' | 'shared';
 export interface SettingsDialogOptions {
     preserveDrawer?: boolean;
@@ -44,8 +66,9 @@ export interface SettingsDialogOptions {
 export declare function normalizeComponentMarketItems(raw: unknown): any[];
 export declare function normalizeComponentsListItems(raw: unknown): any[];
 export declare function showRuleChainSelector(ctx: EditorContext): void;
-export declare function showSettingsDialog(ctx: EditorContext, initialTab?: SettingsDialogTab, options?: SettingsDialogOptions): void;
+export declare function showSettingsDialog(sourceContext: EditorContext, initialTab?: SettingsDialogTab, options?: SettingsDialogOptions): void;
 export declare function showImportDialog(ctx: EditorContext): void;
 export declare function showExportDialog(ctx: EditorContext): void;
+export declare function showDebugLogDialog(ctx: EditorContext): Promise<void>;
 export declare function showRunPanel(ctx: EditorContext, options?: RunPanelOptions): void;
 export declare function showComponentManage(ctx: EditorContext, initialTab?: ComponentManageDialogTab): void;

package/dist/standalone/editor-global-config.d.ts

@@ -0,0 +1,44 @@
+import { type GlobalConfigTransportContext } from '../api/GlobalConfigAPI';
+import { type GlobalConfigFetcher } from '../core/global-config';
+export interface GlobalConfigEditorContext extends GlobalConfigTransportContext {
+    opts: any;
+    core?: any;
+    lf?: any;
+    capabilities?: {
+        editor?: {
+            readOnly?: boolean;
+        };
+        mode?: string;
+    };
+    rootEl?: HTMLElement;
+    _currentTheme?: string;
+    _activeModalWrapper?: HTMLElement | null;
+    _closeModal?(): void;
+    _markDirty?(reason?: string): void;
+    t?(key: string, params?: Record<string, string>): string;
+}
+export interface GlobalConfigPanelOptions {
+    fetcher?: GlobalConfigFetcher;
+}
+export interface GlobalConfigPanel {
+    element: HTMLElement;
+    ready: Promise<void>;
+    reload(): Promise<void>;
+    hasPendingChanges(): boolean;
+    requestClose(): Promise<boolean>;
+    destroy(): void;
+}
+export interface GlobalConfigDialogOptions extends GlobalConfigPanelOptions {
+    delegateToHost?: boolean;
+}
+export interface ConfigDialogHandle {
+    element: HTMLElement;
+    close(): void;
+    requestClose(): Promise<boolean>;
+}
+export declare function mountGlobalConfigPanel(ctx: GlobalConfigEditorContext, container: HTMLElement, options?: GlobalConfigPanelOptions): GlobalConfigPanel;
+export declare function showGlobalConfigDialog(ctx: GlobalConfigEditorContext, options?: GlobalConfigDialogOptions): (ConfigDialogHandle & {
+    panel: GlobalConfigPanel;
+}) | undefined;
+export declare function showNodeLogDialog(ctx: GlobalConfigEditorContext, nodeId: string): ConfigDialogHandle | undefined;
+export declare function showChainLogDialog(ctx: GlobalConfigEditorContext): ConfigDialogHandle | undefined;

package/dist/standalone/editor-group-interactions.d.ts

@@ -0,0 +1 @@
+export declare function registerEditorGroupInteractions(editor: any): () => void;

package/dist/standalone/editor-host-region-styles.d.ts

@@ -0,0 +1 @@
+export declare function injectHostRegionStyles(document: Document): void;

package/dist/standalone/editor-host-regions.d.ts

@@ -0,0 +1,53 @@
+import type { HuanbanRulegoEditor } from './HuanbanRulegoEditor';
+import type { EditorHeaderBadge } from '../types/editor';
+export declare const EDITOR_REGION_IDS: readonly ["header", "toolbar.top", "workspace.tabs", "dock.left", "dock.right", "dock.bottom", "dock.ai", "toolbar.canvas", "canvas.overlay", "status", "overlay.host"];
+export declare function mergeEditorRendererMap<T>(previous: Record<string, T | undefined> | undefined, patch: Record<string, T | undefined>): Record<string, T>;
+export declare function syncEditorHeaderBadges(header: HTMLElement, badges?: readonly EditorHeaderBadge[]): boolean;
+export declare class EditorHostRegions {
+    private readonly editor;
+    private readonly regions;
+    private readonly mounts;
+    private readonly docks;
+    private readonly panelViews;
+    private readonly outlets;
+    private readonly definitions;
+    private readonly releasedDefinitions;
+    private readonly cleanups;
+    private readonly prefix;
+    private sequence;
+    private resizing;
+    private resizingDock;
+    private refreshing;
+    private queued;
+    private destroyed;
+    private changingDefinitions;
+    private chainId;
+    private transportGeneration;
+    private transportContext;
+    constructor(editor: HuanbanRulegoEditor);
+    private readChainId;
+    private readTransportContext;
+    private queueRefresh;
+    refresh(): void;
+    private syncDefinitions;
+    private createElement;
+    private placeRegion;
+    private context;
+    private syncMount;
+    private removeMount;
+    private report;
+    private button;
+    private getDock;
+    private getPanelView;
+    private removePanelView;
+    private panelTitle;
+    private syncPanels;
+    private regionVisible;
+    private syncVisibility;
+    private text;
+    private label;
+    private dimension;
+    private startResize;
+    private clearMounts;
+    destroy(): void;
+}

package/dist/standalone/editor-login.d.ts

@@ -0,0 +1,15 @@
+import type { IdentityProvider } from '../core/IdentityProvider';
+export interface EditorLoginOverlayOptions {
+    identityProvider: IdentityProvider;
+    t?: (key: string, fallback?: string) => string;
+    mode?: 'dialog' | 'fullscreen';
+    onSuccess?: () => void;
+    onDismiss?: () => void;
+}
+export interface EditorLoginOverlay {
+    show(container: HTMLElement): void;
+    hide(): void;
+    isVisible(): boolean;
+}
+export declare function createEditorLoginOverlay(options: EditorLoginOverlayOptions): EditorLoginOverlay;
+export declare function injectLoginOverlayStyles(): void;

package/dist/standalone/editor-overlays.d.ts

@@ -3,12 +3,17 @@ export interface NodePickerOpenOptions {
     clientX?: number;
     clientY?: number;
     sourceNodeId?: string;
+    sourceAnchorId?: string;
     edgeId?: string;
+    loopGroupId?: string;
     excludeInputNodes?: boolean;
     onSelect?: (component: ComponentDefinition, node: unknown) => void;
 }
 export declare function openCommandPalette(editor: any): void;
 export declare function openShortcutHelp(editor: any): void;
+export declare function supportsCanvasConnection(nodeOrComponent: any, direction: 'input' | 'output'): boolean;
+export declare function addPickedNode(editor: any, component: ComponentDefinition, options?: NodePickerOpenOptions): unknown;
 export declare function openNodePicker(editor: any, options?: NodePickerOpenOptions): void;
 export declare function openComponentDocs(editor: any, initialType?: string): Promise<void>;
+export declare function openAboutDialog(editor: any): void;
 export declare function closeSharedOverlay(editor: any): void;

package/dist/standalone/editor-property-drawers.d.ts

@@ -1,8 +1,11 @@
 import type { ServerStatus, ServerStatusState } from '../core/server-status';
+export { createDrawerLocaleController } from './drawer-locale';
 export interface PropertyDrawerContext {
     lf: any;
     core: any;
     opts: any;
+    _dialogProvider?: import('../core/DialogProvider').DialogProvider;
+    identityProvider?: import('../core/IdentityProvider').IdentityProvider;
     serverStatus?: {
         recordWebSocketStatus: (status: string, closeCode?: number | null, message?: string) => ServerStatus | void;
         setReconnectAttempt?: (attempt: number) => unknown;
@@ -47,4 +50,3 @@ export interface NodeRelationSummarySection {
 export declare function buildNodeRelationSummary(model: any, nodeView: any, ctx?: PropertyDrawerContext): NodeRelationSummarySection[];
 export declare function showNodePropertyDrawer(sourceContext: PropertyDrawerContext, model: any, nodeView: any, fromAdd: boolean): void;
 export declare function showEdgePropertyDrawer(sourceContext: PropertyDrawerContext, edgeModel: any, sourceNodeView: any, fromAdd: boolean, usedRelationTypes?: string[], sourceNodeModel?: any): void;
-export {};

package/dist/standalone/editor-run-analysis.d.ts

@@ -0,0 +1,81 @@
+import { type RunAnalysisRecord, type RunNodeLog } from '../core/run-analysis';
+import { type JsonPathDiff } from '../core/rule-chain-versions';
+import { type AnalysisI18nOptions, type AnalysisTranslator } from '../defaults/analysis-locales';
+export interface AnalysisEditor {
+    opts?: {
+        locale?: string;
+        theme?: string;
+    };
+    rootEl?: HTMLElement;
+    t?: (key: string, params?: Record<string, string>) => string;
+    _activeModalWrapper?: HTMLElement | null;
+    _closeModal?: () => void;
+}
+export interface AnalysisViewOptions extends AnalysisI18nOptions {
+    theme?: string;
+    nodeNames?: Readonly<Record<string, string>>;
+    notify?: (message: string, type: 'info' | 'error') => void;
+    onNodeSelect?: (nodeId: string) => void;
+}
+export interface AnalysisDialogHandle {
+    element: HTMLElement;
+    refreshLocale(): void;
+    close(): void;
+    destroy(): void;
+}
+type AnalysisText = string | (() => string);
+export declare function bindAnalysisLocale(element: Element, update: () => void): void;
+export declare function refreshAnalysisLocale(root: HTMLElement): void;
+export declare function analysisElement<K extends keyof HTMLElementTagNameMap>(tag: K, className?: string, text?: AnalysisText): HTMLElementTagNameMap[K];
+export declare function analysisButton(icon: string, label: AnalysisText, action: () => void, iconOnly?: boolean): HTMLButtonElement;
+export declare function createAnalysisSurface(container: HTMLElement, options?: AnalysisViewOptions): HTMLElement;
+export declare function appendAnalysisJson(parent: HTMLElement, title: AnalysisText, data: unknown, t: AnalysisTranslator, notify?: AnalysisViewOptions['notify']): void;
+export declare function appendAnalysisDiff(parent: HTMLElement, title: AnalysisText, changes: readonly JsonPathDiff[], t: AnalysisTranslator): void;
+export declare function createAnalysisModal(editor: AnalysisEditor, title: AnalysisText, options: AnalysisViewOptions): AnalysisDialogHandle & {
+    body: HTMLElement;
+    addCleanup(cleanup: () => void): void;
+    addLocaleRefresh(refresh: () => void): void;
+};
+export interface RunWaterfallViewOptions extends AnalysisViewOptions {
+    logs: readonly RunNodeLog[];
+    scaleMs?: number;
+    observedUntil?: number;
+}
+export declare function createRunWaterfall(container: HTMLElement, initial: RunWaterfallViewOptions): {
+    element: HTMLElement;
+    update(options: RunWaterfallViewOptions): void;
+    refreshLocale(): void;
+    destroy(): void;
+};
+export interface RunComparePanelOptions extends AnalysisViewOptions {
+    detailA: RunAnalysisRecord;
+    detailB: RunAnalysisRecord;
+}
+export declare function createRunComparePanel(container: HTMLElement, initial: RunComparePanelOptions): {
+    element: HTMLElement;
+    update(options: RunComparePanelOptions): void;
+    refreshLocale(): void;
+    destroy(): void;
+};
+export interface RunAnalysisSelectionOptions extends AnalysisViewOptions {
+    records: readonly RunAnalysisRecord[];
+    loadDetail?: (record: RunAnalysisRecord, signal: AbortSignal) => Promise<RunAnalysisRecord>;
+}
+export declare function createRunAnalysis(container: HTMLElement, initial: RunAnalysisSelectionOptions): {
+    element: HTMLElement;
+    refreshLocale(): void;
+    setRecords(records: readonly RunAnalysisRecord[]): void;
+    compare(a: RunAnalysisRecord, b: RunAnalysisRecord): Promise<boolean>;
+    destroy(): void;
+};
+export type RunAnalysisDialogOptions = AnalysisViewOptions & ({
+    record: RunAnalysisRecord;
+} | {
+    detailA: RunAnalysisRecord;
+    detailB: RunAnalysisRecord;
+} | {
+    records: readonly RunAnalysisRecord[];
+    loadDetail?: RunAnalysisSelectionOptions['loadDetail'];
+});
+export declare function showRunAnalysis(editor: AnalysisEditor, options: RunAnalysisDialogOptions): AnalysisDialogHandle;
+export {};

package/dist/standalone/editor-run-compare.d.ts

@@ -0,0 +1,20 @@
+import type { RunComparison, RunComparisonRow, RunComparisonStatus } from '../core/run-analysis';
+export type { RunComparison, RunComparisonRow, RunComparisonStatus };
+export interface RunCompareRunInfo {
+    id: string;
+    label?: string;
+    totalDuration: number | null;
+    success: boolean | null;
+    error?: string;
+}
+export interface RunCompareOptions {
+    comparison: RunComparison;
+    runA: RunCompareRunInfo;
+    runB: RunCompareRunInfo;
+    nodeNames?: Readonly<Record<string, string>>;
+    onNodeClick?: (nodeId: string) => void;
+    t?: (key: string) => string;
+}
+export declare function renderRunCompare(container: HTMLElement, options: RunCompareOptions): {
+    destroy: () => void;
+};

package/dist/standalone/editor-run-waterfall.d.ts

@@ -0,0 +1,11 @@
+import type { RunWaterfall, RunWaterfallRow } from '../core/run-analysis';
+export type { RunWaterfall, RunWaterfallRow };
+export interface RunWaterfallOptions {
+    waterfall: RunWaterfall;
+    nodeNames?: Readonly<Record<string, string>>;
+    onNodeClick?: (nodeId: string) => void;
+    t?: (key: string) => string;
+}
+export declare function renderRunWaterfall(container: HTMLElement, options: RunWaterfallOptions): {
+    destroy: () => void;
+};

package/dist/standalone/editor-toast.d.ts

@@ -1 +1 @@
-export declare function showEditorToast(_editor: any, message: string, type?: 'error' | 'info'): void;
+export declare function showEditorToast(editor: any, message: string, type?: 'error' | 'info'): void;

package/dist/standalone/editor-toolbar-presentation.d.ts

@@ -0,0 +1,12 @@
+import type { EditorCapabilities } from '../core/editor-capabilities';
+import type { EditorToolbarOptions, EditorToolbarRegion } from '../core/editor-capabilities';
+export declare const TOOLBAR_ACTION_IDS: Readonly<Record<string, string>>;
+export declare const TOOLBAR_CAPABILITIES: Readonly<Record<string, string>>;
+export declare function toolbarActionLabel(editor: any, action: string, fallback?: string): string;
+export declare function isToolbarItemVisible(options: EditorToolbarOptions | undefined, id: string, region?: EditorToolbarRegion): boolean;
+export declare function applyToolbarPresentation(editor: any, toolbar: HTMLElement, region: 'top' | 'canvas', visibility?: Record<string, boolean>): void;
+export declare const PREVIEW_HIDDEN_ACTIONS: ReadonlySet<string>;
+export declare function resolvePreviewVisibility(capabilities: EditorCapabilities, actionIds: readonly string[]): Record<string, boolean>;
+export declare const PREVIEW_VISIBLE_ACTIONS: ReadonlySet<string>;
+export declare function applyPreviewBadge(toolbar: HTMLElement, capabilities: EditorCapabilities, label?: string): void;
+export declare function isPreviewActionVisible(capabilities: EditorCapabilities, actionId: string): boolean | undefined;

package/dist/standalone/editor-toolbar.d.ts

@@ -1,3 +1,4 @@
+import type { EditorSaveOptions } from './HuanbanRulegoEditor';
 type ExternalOperationResult = void | boolean | {
     success?: boolean;
     ok?: boolean;
@@ -9,7 +10,8 @@ type ExternalOperationResult = void | boolean | {
     message?: string;
 };
 export declare function isExternalOperationSuccess(result: ExternalOperationResult): boolean;
-export declare function handleToolbarClick(editor: any, e: Event): void | Promise<void>;
+export declare function compareSavedRuleChain(expected: unknown, actual: unknown): string[];
+export declare function handleToolbarClick(editor: any, e: Event, fromRegistry?: boolean): void | Promise<void>;
 export declare function updateToolbarHistoryState(editor: any, state?: {
     undoAble?: boolean;
     redoAble?: boolean;
@@ -21,9 +23,11 @@ export declare function refreshToolbarTexts(editor: any): void;
 export declare function refreshSidebarTexts(editor: any): void;
 export declare function currentThemeLabel(editor: any): string;
 export declare function applyTheme(editor: any, themeId: string): void;
+export declare function syncThemeView(editor: any, themeId: string): void;
 export declare function toggleThemeMenu(editor: any, target?: Element | null): void;
 export declare function closeThemeMenu(editor: any): void;
 export declare function refreshThemeDropdown(editor: any): void;
 export declare function cancelPendingEditorSave(editor: any): void;
+export declare function saveEditor(editor: any, options?: EditorSaveOptions, button?: HTMLElement): Promise<boolean>;
 export declare function setupKeyboardShortcuts(editor: any): () => void;
 export {};

package/dist/standalone/editor-ui-configuration.d.ts

@@ -0,0 +1,55 @@
+import type { EditorCapabilityInput, EditorCapabilities, EditorUiCapabilities } from '../core/editor-capabilities';
+import type { CanvasGridType } from './canvas-view';
+export type EditorBuiltinSettingsTab = 'interface' | 'user' | 'setting' | 'ai' | 'skills' | 'globalConfig';
+export interface EditorSettingControlOptions {
+    visible?: boolean;
+    editable?: boolean;
+}
+export interface EditorSettingsOptions {
+    tabs?: Partial<Record<EditorBuiltinSettingsTab | (string & {}), {
+        visible?: boolean;
+    }>>;
+    fields?: Partial<Record<'apiBase' | 'browserConsoleLog', EditorSettingControlOptions>>;
+}
+export interface EditorUiSettingsOptions {
+    visible?: boolean;
+    editable?: boolean;
+    controls?: Record<string, EditorSettingControlOptions | undefined>;
+}
+export interface EditorUiConfiguration {
+    capabilities?: {
+        ui?: Partial<EditorUiCapabilities>;
+        workspace?: Partial<Pick<EditorCapabilities['workspace'], 'topBar' | 'tabs' | 'explorer' | 'palette'>>;
+    };
+    toolbar?: EditorCapabilityInput['toolbar'];
+    header?: EditorCapabilityInput['header'];
+    settings?: Pick<EditorSettingsOptions, 'tabs'>;
+    toolbarIconOnly?: boolean;
+    canvasGridType?: CanvasGridType;
+    hideEdgeLabels?: boolean;
+    sidebarCollapsed?: boolean;
+}
+export interface EditorUiSettingsChange {
+    configuration: EditorUiConfiguration;
+    source: 'settings' | 'reset';
+}
+export declare function mergeEditorSettingsOptions(previous?: EditorSettingsOptions, patch?: EditorSettingsOptions): EditorSettingsOptions;
+export declare function mergeEditorUiSettingsOptions(previous?: EditorUiSettingsOptions, patch?: EditorUiSettingsOptions): EditorUiSettingsOptions;
+export declare function isEditorSettingsTabVisible(options: {
+    settings?: EditorSettingsOptions;
+    uiSettings?: EditorUiSettingsOptions;
+}, id: string): boolean;
+export declare function pickEditorUiConfiguration(source: Record<string, any>): EditorUiConfiguration;
+export declare class EditorUiSettingsState {
+    private baseline;
+    private host;
+    changed: boolean;
+    constructor(options: EditorCapabilityInput & Record<string, any>);
+    private capabilityInput;
+    updateHost(patch: Record<string, any>): void;
+    isLocked(group: 'ui' | 'workspace', key: string): boolean;
+    isControlLocked(path: string): boolean;
+    private valueAt;
+    constrain(patch: EditorUiConfiguration, current?: Record<string, any>): EditorUiConfiguration | null;
+    resetPatch(current: Record<string, any>): EditorUiConfiguration;
+}

package/dist/standalone/editor-ui-settings.d.ts

@@ -0,0 +1,26 @@
+import type { EditorCapabilities } from '../core/editor-capabilities';
+import type { EditorUiConfiguration, EditorUiSettingsOptions } from './editor-ui-configuration';
+export interface UiSettingsContext {
+    opts: Record<string, any> & {
+        uiSettings?: EditorUiSettingsOptions;
+    };
+    capabilities: EditorCapabilities;
+    core?: {
+        eventBus?: {
+            on(event: string, handler: () => void): (() => void) | void;
+        };
+    };
+    rootEl?: HTMLElement;
+    lf?: any;
+    t(key: string): string;
+    getUiConfiguration(): EditorUiConfiguration;
+    applyUiConfiguration(patch: EditorUiConfiguration): boolean;
+    resetUiConfiguration(): boolean;
+    isUiSettingLocked(group: 'ui' | 'workspace', key: string): boolean;
+    isUiControlLocked?(path: string): boolean;
+}
+export declare function mountEditorUiSettings(editor: UiSettingsContext, container: HTMLElement): {
+    element: HTMLDivElement;
+    refreshLocale: () => void;
+    destroy(): void;
+};

package/dist/standalone/editor-user-menu.d.ts

@@ -0,0 +1,8 @@
+import type { IdentityProvider } from '../core/IdentityProvider';
+export interface UserMenuContext {
+    identityProvider: IdentityProvider;
+    rootEl?: HTMLElement | null;
+    t(key: string, params?: Record<string, string>): string;
+    _showSettingsDialog?(tab?: string): void;
+}
+export declare function renderUserMenu(ctx: UserMenuContext): () => void;

package/dist/standalone/editor-version-history.d.ts

@@ -0,0 +1,82 @@
+import { type RuleChainVersionsAPIOptions } from '../api/RuleChainVersionsAPI';
+import type { RuleChainAPIOptions } from '../api/types';
+import { type RuleChainVersionsFetcher, type RuleChainVersionsController, type RuleChainVersionsControllerOptions, type VersionRollbackResult } from '../core/rule-chain-versions';
+import type { RuleChainData } from '../types/rule-chain';
+import { type AnalysisEditor, type AnalysisViewOptions } from './editor-run-analysis';
+import { type DialogProvider } from '../core/DialogProvider';
+export interface VersionHistoryViewOptions extends AnalysisViewOptions {
+    chainId: string;
+    fetcher: RuleChainVersionsFetcher;
+    pageSize?: number;
+    isDirty: () => boolean;
+    readonly?: boolean | (() => boolean);
+    canRollback?: () => boolean;
+    getDraftRevision?: () => unknown;
+    confirm?: RuleChainVersionsControllerOptions['confirm'];
+    dialogProvider?: DialogProvider;
+    applyRollback?: RuleChainVersionsControllerOptions['onRolledBack'];
+    onRolledBack?: (result: VersionRollbackResult) => void;
+}
+export interface VersionHistoryView {
+    element: HTMLElement;
+    controller: RuleChainVersionsController;
+    ready: Promise<boolean>;
+    refreshLocale(): void;
+    destroy(): void;
+}
+export declare function createVersionHistory(container: HTMLElement, options: VersionHistoryViewOptions): VersionHistoryView;
+export interface VersionHistoryEditor extends AnalysisEditor {
+    _dialogProvider?: DialogProvider;
+    opts?: AnalysisEditor['opts'] & {
+        apiBase?: string;
+        fetchTimeout?: number;
+        fetchHeaders?: RuleChainAPIOptions['headers'];
+        customFetch?: RuleChainAPIOptions['customFetch'];
+        credentials?: RequestCredentials;
+        onApiAuthRequired?: RuleChainAPIOptions['onAuthRequired'];
+        disabled?: boolean;
+        readonly?: boolean;
+        mode?: string;
+    };
+    core?: {
+        store: {
+            getState(): {
+                ruleChain?: {
+                    id?: string;
+                } | null;
+                isDirty?: boolean;
+            };
+        };
+    };
+    workspace?: {
+        getActiveTab(): {
+            id: string;
+            chainId: string;
+            readonly?: boolean;
+        } | null;
+    };
+    capabilities?: {
+        editor?: {
+            readOnly?: boolean;
+        };
+        persistence?: {
+            saveToServer?: boolean;
+        };
+    };
+    serverStatus?: RuleChainAPIOptions['serverStatus'];
+    exportData?(): unknown;
+    loadData(data: RuleChainData, options?: {
+        preserveWorkspaceTab?: boolean;
+    }): void;
+    _markSavedSnapshot?(data?: RuleChainData): void;
+}
+export interface VersionHistoryOptions extends Omit<VersionHistoryViewOptions, 'chainId' | 'fetcher' | 'isDirty'> {
+    chainId?: string;
+    fetcher?: RuleChainVersionsFetcher;
+    isDirty?: () => boolean;
+    apiOptions?: RuleChainVersionsAPIOptions | (() => RuleChainVersionsAPIOptions);
+}
+export interface VersionHistoryHandle extends VersionHistoryView {
+    close(): void;
+}
+export declare function showVersionHistory(editor: VersionHistoryEditor, options?: VersionHistoryOptions): VersionHistoryHandle;

package/dist/standalone/editor-workspace-shell.d.ts

@@ -0,0 +1,47 @@
+import type { HuanbanRulegoEditor } from './HuanbanRulegoEditor';
+import type { RuleChainData } from '../types/rule-chain';
+export declare function fetchWorkspaceRuleChain(editor: HuanbanRulegoEditor, id: string, signal?: AbortSignal): Promise<RuleChainData>;
+export declare class EditorWorkspaceShell {
+    private readonly editor;
+    private readonly tabsEl;
+    private readonly navEl;
+    private readonly resourceEl;
+    private readonly paletteEl;
+    private readonly unsubscribe;
+    private menu;
+    private mode;
+    private rows;
+    private page;
+    private total;
+    private hasMore;
+    private loading;
+    private loaded;
+    private error;
+    private query;
+    private request;
+    private generation;
+    private timer;
+    private destroyed;
+    private readonly closingTabs;
+    private readonly closeController;
+    private tabSignature;
+    private resourceSignature;
+    private outsideClick;
+    private escapeMenu;
+    constructor(editor: HuanbanRulegoEditor);
+    refresh(): void;
+    show(mode: 'components' | 'resources'): void;
+    invalidate(): void;
+    private renderTabs;
+    private handleTabClick;
+    closeTab(id: string): Promise<boolean>;
+    private showTabMenu;
+    private showOpenTabs;
+    private closeMany;
+    private openMenu;
+    private closeMenu;
+    private load;
+    private renderResources;
+    destroy(): void;
+}
+export declare function reportWorkspaceError(editor: HuanbanRulegoEditor, error: unknown): void;

package/dist/standalone/editor-workspace-styles.d.ts

@@ -0,0 +1 @@
+export declare const EDITOR_WORKSPACE_STYLES = "\n.hb_workspace_tabs { display:flex; flex:none; min-width:0; min-height:34px; border-bottom:1px solid var(--hb-border-color); background:var(--hb-bg-toolbar); }\n.hb_workspace_tabs[hidden], .hb_workspace_nav[hidden], .hb_workspace_palette[hidden], .hb_workspace_resources[hidden] { display:none!important; }\n.hb_workspace_tab_list { display:flex; flex:1; min-width:0; overflow-x:auto; scrollbar-width:thin; }\n.hb_workspace_tab { display:flex; align-items:center; flex:none; min-width:100px; max-width:220px; border-right:1px solid var(--hb-border-color); border-top:2px solid transparent; }\n.hb_workspace_tab.is_active { background:var(--hb-bg-canvas,var(--hb-bg-panel)); border-top-color:var(--hb-color-primary); }\n.hb_workspace_tabs button, .hb_workspace_nav button, .hb_workspace_resource_tools button { display:inline-flex; align-items:center; justify-content:center; gap:6px; height:32px; min-width:28px; padding:0 7px; border:0; color:var(--hb-text-secondary); background:transparent; cursor:pointer; font:inherit; }\n.hb_workspace_tab > [role=tab] { min-width:0; flex:1; justify-content:flex-start; }\n.hb_workspace_tab.is_active > [role=tab] { color:var(--hb-text-primary); }\n.hb_workspace_tab_title { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }\n.hb_workspace_tab .hb_control_icon { flex:none; }\n.hb_workspace_tab_close { flex:none; opacity:.7; }\n.hb_workspace_dirty { flex:none; width:6px; height:6px; border-radius:50%; background:var(--hb-color-primary); }\n.hb_workspace_tab_tools { display:flex; flex:none; border-left:1px solid var(--hb-border-color); }\n.hb_workspace_nav { display:flex; flex:none; min-height:34px; border-bottom:1px solid var(--hb-border-color); }\n.hb_workspace_nav button { flex:1 1 auto; min-width:0; padding:0 5px; gap:4px; font-size:12px; border-bottom:2px solid transparent; }\n.hb_workspace_nav button > span:not(.hb_control_icon) { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }\n.hb_workspace_nav button[aria-selected=true] { color:var(--hb-color-primary); border-bottom-color:var(--hb-color-primary); }\n.hb_workspace_palette, .hb_workspace_resources { display:flex; flex:1; flex-direction:column; min-height:0; overflow:hidden; }\n.hb_workspace_resource_tools { display:flex; align-items:center; gap:3px; padding:6px; flex:none; border-bottom:1px solid var(--hb-border-color); }\n.hb_workspace_resource_tools input { width:0; min-width:0; flex:1; height:28px; padding:0 7px; border:1px solid var(--hb-border-color); border-radius:4px; background:var(--hb-bg-input,var(--hb-bg-panel)); color:var(--hb-text-primary); font:inherit; font-size:12px; }\n.hb_workspace_resource_list { flex:1; min-height:0; overflow:auto; }\n.hb_workspace_resource_list summary { display:flex; align-items:center; gap:6px; min-height:30px; padding:3px 8px; cursor:pointer; color:var(--hb-text-secondary); font-size:11px; font-weight:600; }\n.hb_workspace_resource_list summary::before { content:'\\25B8'; flex:none; }\n.hb_workspace_resource_list details[open] > summary::before { content:'\\25BE'; }\n.hb_workspace_resource_list summary > span { flex:1; overflow-wrap:anywhere; }\n.hb_workspace_resource_list summary small { font-weight:400; }\n.hb_workspace_resource { display:flex; gap:7px; align-items:center; width:100%; min-height:42px; padding:5px 10px; border:0; border-left:2px solid transparent; background:transparent; color:var(--hb-text-primary); cursor:pointer; font:inherit; text-align:left; }\n.hb_workspace_resource > span:not(.hb_control_icon) { flex:1; min-width:0; display:flex; flex-direction:column; }\n.hb_workspace_resource strong { font-size:12px; line-height:17px; font-weight:500; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }\n.hb_workspace_resource small { color:var(--hb-text-secondary); font-size:10px; white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }\n.hb_workspace_resource.is_active { border-left-color:var(--hb-color-primary); background:var(--hb-bg-active,var(--hb-bg-hover)); }\n.hb_workspace_tabs button:hover, .hb_workspace_nav button:hover, .hb_workspace_resource:hover, .hb_workspace_menu button:hover { background:var(--hb-bg-hover); }\n.hb_workspace_tabs button:focus-visible, .hb_workspace_nav button:focus-visible, .hb_workspace_resource:focus-visible, .hb_workspace_menu button:focus-visible { outline:2px solid var(--hb-color-primary); outline-offset:-2px; }\n.hb_workspace_lifecycle { width:6px; height:6px; border-radius:50%; background:var(--hb-text-secondary); flex:none; }\n.hb_workspace_lifecycle.is_running { background:var(--hb-color-success,#2b8a57); }\n.hb_workspace_resource_footer { display:flex; flex:none; flex-wrap:wrap; gap:6px; align-items:center; justify-content:space-between; padding:6px 8px; border-top:1px solid var(--hb-border-color); color:var(--hb-text-secondary); font-size:11px; }\n.hb_workspace_resource_footer button { border:0; background:transparent; color:var(--hb-color-primary); cursor:pointer; font:inherit; }\n.hb_workspace_resource_footer p { width:100%; margin:0; color:var(--hb-color-danger,#b42318); overflow-wrap:anywhere; }\n.hb_workspace_empty { color:var(--hb-text-secondary); padding:12px; font-size:12px; }\n.hb_workspace_menu { position:absolute; z-index:var(--hb-z-context-menu,10000); display:flex; flex-direction:column; padding:4px; min-width:180px; max-width:min(320px,calc(100% - 8px)); max-height:calc(100% - 8px); overflow:auto; border:1px solid var(--hb-border-color); border-radius:6px; background:var(--hb-bg-modal); box-shadow:0 8px 24px #0002; }\n.hb_workspace_menu button { display:flex; flex:none; align-items:center; gap:8px; padding:7px 9px; border:0; border-radius:3px; background:transparent; color:var(--hb-text-primary); font:inherit; font-size:12px; cursor:pointer; text-align:left; }\n.hb_workspace_menu button span:not(.hb_control_icon) { min-width:0; overflow-wrap:anywhere; }\n.huanban_rulego_editor_sidebar.collapsed .hb_workspace_nav, .huanban_rulego_editor_sidebar.collapsed .hb_workspace_palette, .huanban_rulego_editor_sidebar.collapsed .hb_workspace_resources { display:none!important; }\n@media(max-width:600px) { .hb_workspace_tab { min-width:88px; max-width:160px; } }\n";

package/dist/standalone/field-expression-preview.d.ts

@@ -0,0 +1,12 @@
+export declare function bindFieldExpressionPreviews(ctx: any, options: {
+    root: HTMLElement;
+    nodeId: string;
+    getConnections: () => Array<{
+        sourceNodeId?: unknown;
+        targetNodeId?: unknown;
+    }>;
+    signal?: AbortSignal;
+}): {
+    refresh(): void;
+    destroy(): void;
+};