@huanban/rulego-editor-core 1.4.2 → 2.0.0

package/dist/nodes/UnknownNodeModel.d.ts

@@ -1,5 +1,16 @@
 import { BaseNodeModel } from '../models/BaseNodeModel';
 export declare class UnknownNodeModel extends BaseNodeModel {
     setAttributes(): void;
-    getNodeStyle(): import("@logicflow/core").LogicFlow.CommonTheme;
+    getNodeStyle(): {
+        [x: string]: unknown;
+        fill?: string | undefined;
+        stroke?: string | undefined;
+        strokeWidth?: number | undefined;
+        radius?: number | undefined;
+        rx?: number | undefined;
+        ry?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        path?: string | undefined;
+    };
 }

package/dist/standalone/HuanbanRulegoEditor.d.ts

@@ -1,8 +1,9 @@
 import LogicFlow from '@logicflow/core';
 import { EditorCore } from '../core/EditorCore';
-import { I18nManager } from '../core/I18nManager';
+import type { DebugWebSocketOptions } from './editor-debug-ws';
+import { I18nManager, type LocaleMessages } from '../core/I18nManager';
 import { EditorDockStore } from '../core/editor-dock';
-import type { EditorDockPersistenceState, EditorPersistenceAdapter, EditorPersistenceMigrationContext, EditorPersistenceNamespace } from '../core/editor-dock';
+import type { EditorDockPersistenceState, EditorDockOptions, EditorPersistenceAdapter, EditorPersistenceMigrationContext, EditorPersistenceNamespace } from '../core/editor-dock';
 import { EditorPanelRegistry } from '../core/editor-panel';
 import { RecentComponentsStore } from '../core/recent-components';
 import type { RecentComponentsPersistenceOptions } from '../core/recent-components';
@@ -12,24 +13,35 @@ import type { EditorPanelPersistenceState } from '../core/editor-panel';
 import { EditorWorkspace } from '../core/EditorWorkspace';
 import { ServerStatusStore } from '../core/server-status';
 import { ConnectionStatusController, ConnectionStatusStore } from '../core/connection-status';
-import type { EditorCapabilities, EditorCapabilitiesOverride, EditorMode } from '../core/editor-capabilities';
-import type { AiProviderOption, EditorOptions } from '../types/editor';
+import type { DialogProvider } from '../core/DialogProvider';
+import type { EditorUiConfiguration, EditorUiSettingsChange, EditorUiSettingsOptions, EditorSettingsOptions } from './editor-ui-configuration';
+import type { EditorCapabilities, EditorCapabilitiesOverride, EditorMode, EditorToolbarOptions } from '../core/editor-capabilities';
+import type { AiProviderOption, EditorOptions, EditorHeaderOptions, EditorHostPanelDefinition, EditorRegionRenderers, EditorPanelRenderers } from '../types/editor';
 import type { FieldChangeHandler } from '../core/FieldChangeRegistry';
+import type { PropertyControlRenderer } from '../core/PropertyControlRegistry';
 import type { RuleChainData } from '../types/rule-chain';
 import type { ComponentDefinition, RawComponentData } from '../types/component';
 import type { DiagnosticItem } from '../core/topology-rules';
-import type { ComponentManageDialogTab, SettingsDialogTab } from './editor-dialogs';
+import type { ComponentManageDialogTab, SettingsDialogTab, EditorSettingsPane } from './editor-dialogs';
 import type { CanvasGridType } from './canvas-view';
 import type { AutoLayoutOptions } from '../core/AutoLayout';
 import { ApiProvider } from '../api/ApiProvider';
-import type { ApiCacheKey } from '../api/types';
+import type { IdentityProvider } from '../core/IdentityProvider';
+import type { ApiCacheKey, WorkflowFetcher } from '../api/types';
 import type { ApiAuthRequiredHandler } from '../api/types';
-import type { EditorActionSource } from '../core/ActionRegistry';
+import type { EditorAction, EditorActionSource } from '../core/ActionRegistry';
 import { type NodePickerOpenOptions } from './editor-overlays';
+import { EditorWorkspaceShell } from './editor-workspace-shell';
+import type { RuleChainVersionsFetcher } from '../core/rule-chain-versions';
+import type { GlobalConfigFetcher } from '../core/global-config';
 export declare function normalizeComponentsRawPayload(data: unknown): unknown;
 export declare function normalizeComponentsPayload(data: unknown): ComponentDefinition[];
 export declare function applyComponentsRuntimePayloadOptions(opts: Record<string, any>, data: unknown): unknown;
 export type EditorSaveMode = 'builtin' | 'host';
+export interface EditorSaveOptions {
+    draft?: boolean;
+    preserveState?: boolean;
+}
 export type ExternalDataUpdatePolicy = 'replace' | 'preserve-dirty';
 export interface EditorShellPersistenceOptions {
     adapter: EditorPersistenceAdapter;
@@ -72,16 +84,17 @@ export type EditorSaveHandlerResult = void | boolean | {
     msg?: string;
     message?: string;
 };
-export type EditorSaveHandler = (data: RuleChainData) => EditorSaveHandlerResult | Promise<EditorSaveHandlerResult>;
+export type EditorSaveHandler = (data: RuleChainData, intent?: EditorSaveOptions) => EditorSaveHandlerResult | Promise<EditorSaveHandlerResult>;
 export interface HuanbanRulegoEditorOptions {
     container: string | HTMLElement;
     apiBase?: string;
+    apiPrefix?: string;
     wsUrl?: string;
     wsBase?: string;
     wsRoot?: string;
     debugWsUrl?: string;
     debugWsBase?: string;
-    debugWsOptions?: Record<string, unknown>;
+    debugWsOptions?: DebugWebSocketOptions;
     debugWsMaxReconnects?: number;
     debugWsMaxLifetimeReconnects?: number;
     debugWsReconnectBaseDelayMs?: number;
@@ -94,7 +107,11 @@ export interface HuanbanRulegoEditorOptions {
     onAuthExpired?: (response: Response) => void;
     onApiAuthRequired?: ApiAuthRequiredHandler;
     clearToken?: () => void;
+    identityProvider?: IdentityProvider;
+    showLoginOverlay?: boolean;
+    showUserMenu?: boolean;
     enableConnectionStatus?: boolean;
+    visible?: boolean;
     data?: RuleChainData | null;
     dataUpdatePolicy?: ExternalDataUpdatePolicy;
     components?: RawComponentData;
@@ -110,6 +127,13 @@ export interface HuanbanRulegoEditorOptions {
     lfOptions?: Record<string, unknown>;
     lfPlugins?: any[];
     coreOptions?: Partial<EditorOptions>;
+    exportDataTransform?: EditorOptions['exportDataTransform'];
+    onNodeConfigRequest?: (node: any, definition: any) => boolean;
+    settingsPanes?: EditorSettingsPane[];
+    settings?: EditorSettingsOptions;
+    uiSettings?: EditorUiSettingsOptions;
+    onUiSettingsChange?: (change: EditorUiSettingsChange) => void;
+    dialogProvider?: DialogProvider;
     canvasGridType?: CanvasGridType;
     hideEdgeLabels?: boolean;
     fieldChangeContributions?: Record<string, FieldChangeHandler>;
@@ -118,6 +142,16 @@ export interface HuanbanRulegoEditorOptions {
     testCases?: EditorRunTestCasesOptions;
     mode?: EditorMode;
     capabilities?: EditorCapabilitiesOverride;
+    toolbar?: EditorToolbarOptions;
+    header?: EditorHeaderOptions;
+    regions?: EditorRegionRenderers;
+    panels?: readonly EditorHostPanelDefinition[];
+    panelRenderers?: EditorPanelRenderers;
+    dock?: Omit<EditorDockOptions, 'persistence'>;
+    showWorkspaceTabs?: boolean;
+    workflowFetcher?: WorkflowFetcher;
+    versionsFetcher?: RuleChainVersionsFetcher;
+    globalConfigFetcher?: GlobalConfigFetcher;
     disabled?: boolean;
     showToolbar?: boolean;
     toolbarTitle?: string;
@@ -125,6 +159,7 @@ export interface HuanbanRulegoEditorOptions {
     toolbarIconOnly?: boolean;
     showSidebar?: boolean;
     sidebarWidth?: number;
+    sidebarLabelLines?: 1 | 2;
     sidebarCollapsed?: boolean;
     sidebarVirtualization?: {
         enabled?: boolean;
@@ -134,6 +169,7 @@ export interface HuanbanRulegoEditorOptions {
         overscan?: number;
     };
     showInfoButton?: boolean;
+    showChainSecrets?: boolean;
     showAiChatButton?: boolean;
     showDebugConsoleButton?: boolean;
     showClearDebugHighlightButton?: boolean;
@@ -181,14 +217,18 @@ export interface HuanbanRulegoEditorOptions {
     onImportDSL?: (data: RuleChainData) => void;
     showRunButton?: boolean;
     onRunClick?: (chainId: string) => void;
+    onFlow?: (phase: 'start' | 'end', chainId: string) => void;
     showTraceButton?: boolean;
     onTraceClick?: (chainInfo: any) => void;
     showComponentManage?: boolean;
     onComponentManage?: (initialTab?: ComponentManageDialogTab) => void;
     locale?: string;
+    messages?: Record<string, LocaleMessages>;
+    autoLoadLocales?: boolean;
     theme?: string;
     onLocaleChange?: (locale: string) => void;
     showDebugTab?: boolean;
+    showPropertyDialogOnDndAdd?: boolean;
     showDeployButton?: boolean;
     showRestartButton?: boolean;
     showReloadButton?: boolean;
@@ -224,6 +264,7 @@ export interface HuanbanRulegoEditorOptions {
     runHistoryUrl?: string;
 }
 export interface AIAssistantOpenOptions {
+    prompt?: string;
     fromNodeId?: string;
     onlyThisNode?: boolean;
     section?: string;
@@ -242,14 +283,28 @@ export declare class HuanbanRulegoEditor {
     readonly connectionStatus: ConnectionStatusStore;
     readonly connectionStatusController: ConnectionStatusController;
     readonly apiProvider: ApiProvider;
+    private activeIdentityProvider;
+    private defaultIdentityProvider?;
+    get identityProvider(): IdentityProvider;
+    private loginOverlay;
+    private _cleanupAuthChange;
     capabilities: EditorCapabilities;
+    private uiSettingsState?;
+    private applyingUiConfiguration;
+    private hostRegions;
     rootEl: HTMLElement | null;
     canvasEl: HTMLElement | null;
     sidebarEl: HTMLElement | null;
     sidebarGroupsEl: HTMLElement | null;
     searchInputEl: HTMLInputElement | null;
-    _activeDrawerWrapper: HTMLElement | null;
-    _activeModalWrapper: HTMLElement | null;
+    private activeDrawerWrapper;
+    private releaseDrawerTheme;
+    get _activeDrawerWrapper(): HTMLElement | null;
+    set _activeDrawerWrapper(wrapper: HTMLElement | null);
+    private activeModalWrapper;
+    private releaseModalTheme;
+    get _activeModalWrapper(): HTMLElement | null;
+    set _activeModalWrapper(wrapper: HTMLElement | null);
     private statusNodes;
     private statusEdges;
     private statusUpdateTime;
@@ -260,6 +315,15 @@ export declare class HuanbanRulegoEditor {
     private aiAssistantUnread;
     private workspaceTabId;
     private savedSnapshotJson;
+    private workspaceSavedSnapshots;
+    private readonly flashAnimations;
+    private readonly hostActions;
+    private readonly removedActions;
+    private workspaceRestorePending;
+    private openChainController;
+    private openChainGeneration;
+    private readonly workspaceViewports;
+    _workspaceShell: EditorWorkspaceShell | null;
     private isFlushingPendingDrawer;
     private isLoadingDataIntoCanvas;
     private diagnosticItems;
@@ -272,6 +336,12 @@ export declare class HuanbanRulegoEditor {
     private componentRebindEligible;
     private destroyed;
     private transportGeneration;
+    private _dirtySuppression;
+    private saveAuthorityGeneration;
+    private canonicalComponents;
+    private componentLocales;
+    private localeController;
+    private savingAll;
     components: ComponentDefinition[];
     readonly recentComponents: RecentComponentsStore;
     readonly testCases: EditorTestCasesStore;
@@ -279,31 +349,55 @@ export declare class HuanbanRulegoEditor {
     opts: HuanbanRulegoEditorOptions;
     i18n: I18nManager;
     _currentTheme: string;
+    _themeRuntimeBound: boolean;
+    private _cleanupThemeRuntime;
     private _cleanupShortcuts;
     private _cleanupContextMenu;
     private _cleanupEdgeLabelQuickEditor;
     private _cleanupBridgeEvents;
     private _cleanupCoreState;
     private _cleanupConnectionStatus;
+    private _cleanupGroupInteractions;
+    private _cleanupCanvasShortcuts;
     private _cleanupFullscreenState;
+    private _cleanupUserMenu;
+    private _showUserMenu;
     _themeMenuBindTimer: ReturnType<typeof setTimeout> | null;
     _themeMenuOutsideClickHandler: ((event: MouseEvent) => void) | null;
     _miniMapVisible: boolean;
+    _dialogProvider: DialogProvider;
+    private ownedDialogProvider?;
     _clipboard: any[];
     _isAutoLayouting: boolean;
     _pendingAutoOptimize: boolean;
     constructor(options: HuanbanRulegoEditorOptions);
     t(key: string, params?: Record<string, string | number>): string;
     setLocale(locale: string): void;
+    registerLocale(locale: string, messages: LocaleMessages): void;
+    setLocales(payload: unknown, locale?: string): void;
+    reloadLocales(): Promise<boolean>;
     setTheme(theme: string): void;
+    refreshTheme(): void;
     registerFieldChangeHandler(name: string, handler: FieldChangeHandler, overwrite?: boolean): void;
+    registerPropertyComponent(type: string, renderer: PropertyControlRenderer, overwrite?: boolean): void;
+    resolvePropertyComponent(type: string): PropertyControlRenderer | undefined;
+    unregisterPropertyComponent(type: string): boolean;
     unregisterFieldChangeHandler(name: string): boolean;
     getTheme(): string;
     _getTransportGeneration(): number;
+    _getSaveAuthorityGeneration(): number;
     getI18n(): I18nManager;
     get runtimeFields(): import("..").RuntimeFieldDictionary | null;
     updateOptions(patch: Partial<Omit<HuanbanRulegoEditorOptions, 'container'>>): EditorOptionsUpdateResult;
     private _syncRuntimeOptionUi;
+    getUiConfiguration(): EditorUiConfiguration;
+    isUiSettingLocked(group: 'ui' | 'workspace', key: string): boolean;
+    isUiControlLocked(path: string): boolean;
+    applyUiConfiguration(patch: EditorUiConfiguration): boolean;
+    resetUiConfiguration(): boolean;
+    private _applyUiConfiguration;
+    private _syncUiSettingsAccess;
+    private _syncHeader;
     toggleMiniMap(): void;
     toggleNodeSearch(): void;
     _searchNodes(keyword: string): number;
@@ -312,6 +406,8 @@ export declare class HuanbanRulegoEditor {
     private _startInitialDataLoadGate;
     private _bindCoreStateSync;
     private _prepareForChainSwitch;
+    private _resolveWorkspaceCapabilities;
+    private _applyWorkspaceCapabilities;
     private createDOM;
     private _renderCanvasToolbar;
     private handleToolbarClick;
@@ -337,8 +433,9 @@ export declare class HuanbanRulegoEditor {
     private _showEdgePropertyDrawer;
     _closeDrawer(): void;
     _closeModal(): void;
+    private _reconcileDirtyAfterSuppression;
     _markDirty(reason?: string): void;
-    _markSavedSnapshot(data?: RuleChainData | null): void;
+    _markSavedSnapshot(data?: RuleChainData | null, canvasSnapshot?: RuleChainData): void;
     _getSavedSnapshot(): RuleChainData | null;
     _markSavedSnapshotFromCanvas(): void;
     private _flushPendingDrawerChanges;
@@ -353,21 +450,43 @@ export declare class HuanbanRulegoEditor {
     _showRuleChainSelector(): void;
     updateStatusBar(): void;
     loadComponents(components: RawComponentData): void;
+    private _applyComponentCatalog;
     reloadComponents(options?: {
         forceRefresh?: boolean;
     }): Promise<boolean>;
     refreshConnectionStatuses(): void;
+    setVisible(visible: boolean): void;
     acquireSharedConnectionStatuses(): () => void;
     private _requestConnectionStatuses;
     loadData(data: RuleChainData, options?: HuanbanRulegoEditorLoadOptions): void;
     activateWorkspaceTab(tabId: string): boolean;
+    captureWorkspaceDraft(): boolean;
+    openRuleChain(chain: string | RuleChainData): Promise<boolean>;
+    resetRuleChain(): Promise<boolean>;
+    requestOpenRuleChain(chain: string | RuleChainData): Promise<boolean>;
+    newRuleChain(root?: boolean): Promise<boolean>;
+    renameWorkspaceRuleChain(tabId: string): Promise<boolean>;
+    closeWorkspaceTab(tabId: string): Promise<boolean>;
+    clearWorkspaceCanvas(): void;
+    save(options?: EditorSaveOptions): Promise<boolean>;
+    showVersionHistory(): void;
+    saveAll(): Promise<boolean>;
+    render(data: RuleChainData): void;
+    getData(): RuleChainData | null;
+    openChain(chain: string | RuleChainData): Promise<boolean>;
+    isDirty(): boolean;
+    getDraftFingerprint(): string;
+    applyRuleChainDraft(data: RuleChainData, expectedFingerprint?: string): Promise<boolean>;
+    flashNodes(ids: string[]): void;
     loadImportedData(data: RuleChainData): void;
     autoLayout(options?: AutoLayoutOptions): void;
     _updateChainStatus(ruleChain?: import('../types/rule-chain').RuleChainConfig | null): void;
     _updateDeployToolbarAction(ruleChain?: import('../types/rule-chain').RuleChainConfig | null): void;
     exportData(): RuleChainData | null;
+    private _exportCanvasData;
     exportAndLog(): void;
     toggleSidebar(): void;
+    setSidebarExpanded(expanded: boolean): void;
     fitView(): void;
     _showImportDialog(): void;
     _showExportDialog(): void;
@@ -377,10 +496,18 @@ export declare class HuanbanRulegoEditor {
         initialMode?: 'form' | 'chat';
         initialTab?: 'response' | 'resp_headers' | 'debug' | 'history' | 'integration';
         section?: string;
+        prompt?: string;
     }): void;
     _showSettingsDialog(initialTab?: SettingsDialogTab): void;
     openSettings(initialTab?: SettingsDialogTab): void;
+    openGlobalConfig(): void;
+    showNodeLogSettings(nodeId: string): void;
+    showChainLogSettings(): void;
     invokeAction(id: string, source?: EditorActionSource): Promise<boolean>;
+    listActions(): EditorAction[];
+    addAction(action: EditorAction): void;
+    removeAction(id: string): boolean;
+    _isActionRemoved(id: string): boolean;
     openCommandPalette(): void;
     openShortcutHelp(): void;
     startTour(): boolean;
@@ -389,7 +516,9 @@ export declare class HuanbanRulegoEditor {
     openComponentDocs(initialType?: string): Promise<void>;
     closeOverlay(): void;
     closeAllOverlays(): void;
-    openAiAssistant(options?: AIAssistantOpenOptions): void;
+    openAiAssistant(options?: AIAssistantOpenOptions): boolean;
+    openChat(prompt?: string): boolean;
+    switchChatChain(chain?: string | RuleChainData): Promise<boolean>;
     closeAiAssistant(): void;
     _showComponentManage(initialTab?: ComponentManageDialogTab): void;
     openComponentManager(initialTab?: ComponentManageDialogTab): void;
@@ -397,6 +526,9 @@ export declare class HuanbanRulegoEditor {
     showChainInfo(): void;
     private _showChainInfoDrawer;
     _escapeHtml(text: string): string;
+    private _syncIdentityContext;
+    private _refreshUserMenu;
+    private _showLoginOverlay;
     destroy(): void;
     private _autoLoadComponents;
     static fetchData(apiBase: string, path: string, legacyFallbackFile?: string, timeout?: number, headers?: Record<string, string>): Promise<unknown>;

package/dist/standalone/auth-fetch.d.ts

@@ -1,4 +1,5 @@
 export declare function getAuthHeaders(editor: any, opts?: any): Record<string, string>;
+export declare function getWebSocketAuthToken(editor: any, url: string): string;
 export interface AuthFetchOptions {
     timeoutMs?: number;
     allowedOrigins?: string[];

package/dist/standalone/auth-ui-defaults.d.ts

@@ -0,0 +1,15 @@
+import type { IdentityProvider } from '../core/IdentityProvider';
+export interface AuthUiOptions {
+    identityProvider?: IdentityProvider;
+    onApiAuthRequired?: unknown;
+    onAuthExpired?: unknown;
+    fetchHeaders?: unknown;
+    showLoginOverlay?: boolean;
+    showUserMenu?: boolean;
+}
+export interface AuthUiDefaults {
+    hostHandlesAuth: boolean;
+    showLoginOverlay: boolean;
+    showUserMenu: boolean;
+}
+export declare function resolveAuthUiDefaults(options: AuthUiOptions): AuthUiDefaults;

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

@@ -26,6 +26,9 @@ export interface CodeEditorOptions {
         value?: string;
         name?: string;
     }>;
+    getGlobalVars?: () => CodeEditorOptions['globalVars'];
+    chainVars?: string[];
+    getChainVars?: () => string[] | undefined;
 }
 export interface CodeEditorInstance {
     getValue(): string;
@@ -37,11 +40,10 @@ export declare function createRulegoCompletionSource(options?: {
     mode?: CodeEditorCompletionMode;
     schemaCompletions?: CodeEditorCompletionItem[];
     getSchemaCompletions?: () => CodeEditorCompletionItem[] | undefined;
-    globalVars?: Array<string | {
-        label?: string;
-        value?: string;
-        name?: string;
-    }>;
+    globalVars?: CodeEditorOptions['globalVars'];
+    getGlobalVars?: CodeEditorOptions['getGlobalVars'];
+    chainVars?: string[];
+    getChainVars?: CodeEditorOptions['getChainVars'];
 }): CompletionSource;
 export declare function createCodeEditor(options: CodeEditorOptions): CodeEditorInstance;
 export declare function validateCode(code: string, lang: CodeEditorLang): true | string;

package/dist/standalone/connection-status-binding.d.ts

@@ -1,8 +1,9 @@
 import type { ConnectionStatusState, ConnectionStatusStore } from '../core/connection-status';
+import type { DirtySuppression } from '../core/clean-snapshot';
 export interface ConnectionStatusBindingHost {
     lf: any;
     connectionStatus: ConnectionStatusStore;
     t?: (key: string) => string;
 }
-export declare function applyConnectionStatusSnapshot(host: ConnectionStatusBindingHost, state: ConnectionStatusState): void;
-export declare function bindConnectionStatusToLogicFlow(host: ConnectionStatusBindingHost): () => void;
+export declare function applyConnectionStatusSnapshot(host: ConnectionStatusBindingHost, state: ConnectionStatusState, suppression?: DirtySuppression | null): void;
+export declare function bindConnectionStatusToLogicFlow(host: ConnectionStatusBindingHost, suppression?: DirtySuppression | null): () => void;

package/dist/standalone/custom-nodes.d.ts

@@ -1,3 +1,16 @@
 import LogicFlow from '@logicflow/core';
+import type { DiagnosticItem } from '../core/topology-rules';
 export type CustomNodeTranslator = (key: string, fallback: string) => string;
+export interface NodeRuntimeAppearance {
+    status?: 'processing' | 'success' | 'error';
+    durationMs?: number;
+    diagnostics?: readonly DiagnosticItem[];
+    debugHighlight?: boolean;
+}
+export declare const NODE_APPEARANCE_EVENT = "rulego-editor:appearance-change";
+export declare function setNodeRuntimeAppearance(model: any, patch: NodeRuntimeAppearance): void;
+export declare function getNodeRuntimeAppearance(model: any): NodeRuntimeAppearance;
+export declare function applyNodeStatusStyle<T extends Record<string, any>>(model: any, style: T): T;
+export declare function renderNodeSelectionOutline(model: any): any | null;
+export declare function renderNodeDecorations(model: any, text: CustomNodeTranslator, offset?: number): any[];
 export declare function registerCustomElements(lf: LogicFlow, translate?: CustomNodeTranslator): void;

package/dist/standalone/drawer-locale.d.ts

@@ -0,0 +1,12 @@
+interface DrawerLocaleContext {
+    t(key: string, params?: Record<string, string>): string;
+}
+interface DrawerLocaleController<T extends DrawerLocaleContext> {
+    sourceContext: T;
+    context: T;
+    recordResolved(key: string, params: Record<string, string> | undefined, fallback: string | undefined, value: string): string;
+    refresh(root: HTMLElement): void;
+}
+export declare function getDrawerLocaleController<T extends DrawerLocaleContext>(context: T): DrawerLocaleController<T> | undefined;
+export declare function createDrawerLocaleController<T extends DrawerLocaleContext>(inputContext: T): DrawerLocaleController<T>;
+export {};

package/dist/standalone/drawer-unsaved-guard.d.ts

@@ -2,6 +2,9 @@ export type DrawerCloseDecision = 'save' | 'discard' | 'cancel';
 export interface DrawerGuardI18nContext {
     t(key: string, params?: Record<string, string>): string;
     _activeDrawerWrapper?: HTMLElement | null;
+    themeOwner?: HTMLElement | null;
+    guardOwner?: object;
+    signal?: AbortSignal;
 }
 export interface DrawerSnapshotOptions {
     selector?: string;
@@ -10,4 +13,6 @@ export interface DrawerSnapshotOptions {
 }
 export declare function captureDrawerFormSnapshot(root: ParentNode, options?: DrawerSnapshotOptions): string;
 export declare function isDrawerFormDirty(root: ParentNode, initialSnapshot: string, options?: DrawerSnapshotOptions): boolean;
-export declare function confirmDrawerUnsavedClose(ctx: DrawerGuardI18nContext): Promise<DrawerCloseDecision>;
+export declare function confirmDrawerUnsavedClose(ctx: DrawerGuardI18nContext & {
+    _dialogProvider?: import('../core/DialogProvider').DialogProvider;
+}): Promise<DrawerCloseDecision>;

package/dist/standalone/dynamic-field-browse.d.ts

@@ -0,0 +1,25 @@
+interface BrowseContext {
+    opts: any;
+    core?: any;
+    capabilities?: {
+        editor?: {
+            readOnly?: boolean;
+        };
+    };
+    i18n?: {
+        getLocale(): string;
+    };
+    _currentTheme?: string;
+    t?(key: string): string;
+}
+export declare function renderDynamicBrowseInput(ctx: BrowseContext, field: any, input: string): string;
+export declare function bindDynamicFieldBrowse(ctx: BrowseContext, options: {
+    root: HTMLElement;
+    getConfiguration: () => Record<string, unknown>;
+    signal?: AbortSignal;
+    readOnly?: () => boolean;
+}): {
+    destroy(): void;
+    refreshLocale(): void;
+};
+export {};

package/dist/standalone/edge-label-quick-editor.d.ts

@@ -1,2 +1,3 @@
-export declare function applyEdgeLabelValues(editor: any, edgeModel: any, values: string[]): boolean;
+export declare function applyEdgeLabelValues(editor: any, edgeModel: any, values: string[]): Promise<boolean>;
+export declare function confirmEndpointBindingRemoval(editor: any, removed: string[]): Promise<boolean>;
 export declare function setupEdgeLabelQuickEditor(editor: any): () => void;

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

@@ -1,4 +1,5 @@
 import type { EditorActionSource, EditorSelectionSnapshot } from '../core/ActionRegistry';
+export declare function isEditorActionAllowed(editor: any, id: string): boolean;
 export declare function getEditorSelectionSnapshot(editor: any): EditorSelectionSnapshot;
 export declare function registerDefaultEditorActions(editor: any): void;
 export declare function invokeEditorAction(editor: any, id: string, source?: EditorActionSource): Promise<boolean>;

package/dist/standalone/editor-canvas-anchors.d.ts

@@ -0,0 +1,19 @@
+export interface CanvasOutputAnchor {
+    id: string;
+    x: number;
+    y: number;
+    type?: string;
+    label?: string;
+    name?: string;
+    edgeAddable?: boolean;
+    [key: string]: unknown;
+}
+export declare function getCanvasOutputAnchors(node: any): CanvasOutputAnchor[];
+export declare function getCanvasSourceAnchor(node: any, anchorId: string): CanvasOutputAnchor | undefined;
+export declare function getCanvasAnchorDirection(node: any, anchor: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};

package/dist/standalone/editor-canvas-shortcuts.d.ts

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

package/dist/standalone/editor-chain-info.d.ts

@@ -3,6 +3,7 @@ export interface ChainInfoContext {
     opts: any;
     t(key: string, params?: Record<string, string>): string;
     _escapeHtml(str: string): string;
+    _dialogProvider?: import('../core/DialogProvider').DialogProvider;
     _activeDrawerWrapper?: HTMLElement | null;
     _activeModalWrapper?: HTMLElement | null;
     _closeDrawer(): void;

package/dist/standalone/editor-debug-data.d.ts

@@ -0,0 +1,18 @@
+export interface DebugDataMessage {
+    msg?: unknown;
+    metadata?: Record<string, string>;
+    msgType?: string;
+}
+export interface DebugDataPanelOptions {
+    data: {
+        input?: DebugDataMessage;
+        output?: DebugDataMessage;
+    };
+    nodeId: string;
+    nodeName: string;
+    t?: (key: string) => string;
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}
+export declare function renderDebugDataPanel(container: HTMLElement, options: DebugDataPanelOptions): {
+    destroy: () => void;
+};

package/dist/standalone/editor-debug-ws.d.ts

@@ -1,3 +1,4 @@
+import { type WebSocketTokenProvider } from '../core/websocket-auth';
 export type WsStatus = 'connecting' | 'live' | 'reconnecting' | 'disconnected' | 'error';
 export type DebugWsStatusReason = 'connecting' | 'connected' | 'socket-error' | 'socket-closed' | 'reconnecting' | 'max-reconnects' | 'manual-stop' | 'destroy';
 export interface DebugWsStatusDetails {
@@ -13,6 +14,7 @@ export interface DebugWebSocketOptions {
     wsUrl?: string;
     wsBase?: string;
     wsRoot?: string;
+    getToken?: WebSocketTokenProvider;
     maxReconnects?: number;
     maxLifetimeReconnects?: number;
     reconnectBaseDelayMs?: number;

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

@@ -1,8 +1,10 @@
 export interface DeleteGraphElementsOptions {
     requireConfirm?: boolean;
     action?: 'delete' | 'disconnect' | 'cancelNewEdge';
+    prepare?: () => (() => void);
 }
-export declare function confirmGraphElementsDelete(editor: any, nodes?: any[], edges?: any[], options?: DeleteGraphElementsOptions): boolean;
+export declare function confirmEditorGraphChange(editor: any, message: string): Promise<boolean>;
+export declare function confirmGraphElementsDelete(editor: any, nodes?: any[], edges?: any[], options?: DeleteGraphElementsOptions): Promise<boolean>;
 export declare function canDeleteNodesWithInputGuard(editor: any, selectedNodes: any[]): boolean;
-export declare function deleteGraphElementsWithInputGuard(editor: any, nodes?: any[], edges?: any[], options?: DeleteGraphElementsOptions): boolean;
-export declare function deleteSelectedElementsWithInputGuard(editor: any): boolean;
+export declare function deleteGraphElementsWithInputGuard(editor: any, nodes?: any[], edges?: any[], options?: DeleteGraphElementsOptions): Promise<boolean>;
+export declare function deleteSelectedElementsWithInputGuard(editor: any): Promise<boolean>;

package/dist/standalone/editor-dialog-provider.d.ts

@@ -0,0 +1,3 @@
+import { type DialogProvider } from '../core/DialogProvider';
+export declare function editorDialogProvider(editor: any): DialogProvider;
+export declare function captureDialogContext(editor: any): () => boolean;