treege 3.0.0-beta.8 → 3.0.0-beta.80

package/dist/editor/components/input/ComboboxWithCreate.d.ts

@@ -5,7 +5,8 @@ export type ComboboxOption = {
 /**
  * Reusable Combobox component with search, create, and clear functionality
  */
-declare const ComboboxWithCreate: ({ options, value, onValueChange, placeholder, searchPlaceholder, createLabel, clearLabel, emptyLabel, className, allowClear, allowCreate, }: {
+declare const ComboboxWithCreate: ({ options, id, value, onValueChange, placeholder, searchPlaceholder, createLabel, clearLabel, emptyLabel, className, allowClear, allowCreate, }: {
+    id?: string;
     options: ComboboxOption[];
     value?: string | null;
     onValueChange?: (newValue: string) => void;

package/dist/editor/components/styles/EditorStyles.d.ts

@@ -0,0 +1,2 @@
+declare const EditorStyles: () => import("react/jsx-runtime").JSX.Element;
+export default EditorStyles;

package/dist/editor/constants/defaultNode.d.ts

@@ -1,4 +1,4 @@
-export declare const defaultNode: {
+export declare const DEFAULT_NODE: {
     data: {
         type: string;
     };

package/dist/editor/constants/edgeTypes.d.ts

@@ -1,3 +1,4 @@
-export declare const edgeTypes: {
-    conditional: ({ id, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: import('../features/TreegeEditor/edges/ConditionalEdge').ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EDGE_TYPES: {
+    conditional: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: import('../features/TreegeEditor/edges/ConditionalEdge').ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
+    default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: import('@xyflow/react').EdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
 };

package/dist/editor/constants/inputTypeIcons.d.ts

@@ -0,0 +1,3 @@
+import { LucideIcon } from 'lucide-react';
+export declare const INPUT_TYPE_ICONS: Record<string, LucideIcon>;
+export declare const DEFAULT_INPUT_TYPE_ICON: import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;

package/dist/editor/constants/nodeSpacing.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Constants for node spacing and positioning in the flow editor
+ */
+/**
+ * Vertical spacing between nodes (in pixels)
+ * Used when creating nodes via handle click or AI generation
+ */
+export declare const VERTICAL_NODE_SPACING = 100;
+/**
+ * Horizontal offset when placing sibling nodes (in pixels)
+ */
+export declare const HORIZONTAL_NODE_OFFSET = 50;
+/**
+ * Default direction for the auto-layout algorithm.
+ * "TB" = top to bottom, "LR" = left to right.
+ */
+export declare const LAYOUT_DIRECTION = "TB";
+/**
+ * Vertical gap between ranks (parent → child) used by the auto-layout (in pixels).
+ */
+export declare const LAYOUT_VERTICAL_SPACING = 80;
+/**
+ * Horizontal gap between siblings used by the auto-layout (in pixels).
+ */
+export declare const LAYOUT_HORIZONTAL_SPACING = 60;

package/dist/editor/constants/nodeTypes.d.ts

@@ -1,6 +1,5 @@
-export declare const nodeTypes: {
-    flow: ({ data, isConnectable, type, parentId }: import('../features/TreegeEditor/nodes/FlowNode').FlowNodeProps) => import("react/jsx-runtime").JSX.Element;
-    group: ({ data }: import('../features/TreegeEditor/nodes/GroupNode').GroupNodeProps) => import("react/jsx-runtime").JSX.Element;
-    input: ({ data, isConnectable, type, parentId }: import('../features/TreegeEditor/nodes/InputNode').InputNodeProps) => import("react/jsx-runtime").JSX.Element;
-    ui: ({ data, isConnectable, type, parentId }: import('../features/TreegeEditor/nodes/UINode').UINodeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const NODE_TYPES: {
+    group: () => null;
+    input: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    ui: import('react').MemoExoticComponent<(props: import('../features/TreegeEditor/nodes/TreegeNode').TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
 };

package/dist/editor/context/OpenApiContext.d.ts

@@ -0,0 +1,79 @@
+import { ReactNode } from 'react';
+import { ApiRoute, OpenApiDocument } from '../types/openapi';
+/**
+ * The exact input the user fed to the OpenAPI dialog last time it loaded
+ * successfully. Kept around so re-opening the dialog can pre-fill the field
+ * (the user may want to tweak/re-load the same source).
+ */
+export type OpenApiSourceInput = {
+    mode: "url";
+    value: string;
+} | {
+    mode: "json";
+    value: string;
+};
+interface OpenApiContextValue {
+    /**
+     * The currently loaded OpenAPI document, or `null` when none is set.
+     */
+    document: OpenApiDocument | null;
+    /**
+     * Memoized flat list of routes derived from `document`.
+     */
+    routes: ApiRoute[];
+    /**
+     * User-provided base URL that overrides the document's `servers[0].url`.
+     * Useful when the OpenAPI spec points at a different environment than the
+     * one the user wants to call (e.g. staging vs prod). Empty string means
+     * "no override — use the document's declared server".
+     */
+    baseUrlOverride: string;
+    /**
+     * Effective base URL: the override when non-empty, otherwise the document's
+     * first declared server. Trailing slash trimmed.
+     */
+    baseUrl: string;
+    /**
+     * Last source input (URL or pasted JSON) used to load the document. `null`
+     * before the user has loaded anything.
+     */
+    lastSourceInput: OpenApiSourceInput | null;
+    /**
+     * Replace the loaded document. Pass `null` to clear.
+     */
+    setDocument: (next: OpenApiDocument | null) => void;
+    /**
+     * Replace the base URL override. Pass `""` to clear.
+     */
+    setBaseUrlOverride: (next: string) => void;
+    /**
+     * Record the last source input the user used to load the document.
+     */
+    setLastSourceInput: (next: OpenApiSourceInput | null) => void;
+}
+interface OpenApiProviderProps {
+    children: ReactNode;
+    /**
+     * Initial OpenAPI source. Accepts either a pre-parsed document or a URL
+     * string — when a URL is given, the provider fetches it on mount and
+     * toasts on failure (matching the runtime behavior of the dialog).
+     */
+    initialDocument?: OpenApiDocument | string | null;
+    /**
+     * Initial base URL. When set, takes precedence over the document's
+     * `servers[0].url`. Empty string means "no override".
+     */
+    initialBaseUrl?: string;
+}
+/**
+ * Holds the current OpenAPI document at editor scope. The document is
+ * editor-local state (not persisted in the flow JSON), so reloading the
+ * editor with a different consumer-supplied initial document is supported.
+ */
+export declare const OpenApiProvider: ({ children, initialDocument, initialBaseUrl }: OpenApiProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Read the OpenAPI context. Returns a no-op default outside of the provider
+ * so consumers (e.g., URL combobox) don't have to null-check.
+ */
+export declare const useOpenApi: () => OpenApiContextValue;
+export {};

package/dist/editor/context/TreegeEditorRuntimeProvider.d.ts

@@ -0,0 +1,78 @@
+import { PropsWithChildren } from 'react';
+import { AIConfig } from '../types/ai';
+import { HttpHeaders } from '../../shared/types/node';
+export interface TreegeEditorRuntimeContextValue {
+    /**
+     * Current language of the editor UI. Also used as the default language for
+     * the per-node translation editor in `InputNodeForm`.
+     */
+    language: string;
+    /**
+     * Set the editor UI language at runtime (driven by the language switcher in
+     * the actions panel). Seeded from the `language` prop, then owned internally;
+     * the consumer can observe changes via `TreegeEditor`'s `onLanguageChange`.
+     */
+    setLanguage: (language: string) => void;
+    /**
+     * Current flow ID
+     */
+    flowId?: string;
+    /**
+     * Global HTTP headers used by editor-time HTTP calls (e.g. the
+     * "Detect fields" button). Forwarded by the consumer; same shape and
+     * semantics as `TreegeRenderer`'s `headers`.
+     */
+    headers?: HttpHeaders;
+    /**
+     * Function to set the current flow ID
+     * @param flow
+     */
+    setFlowId?: (flow?: string) => void;
+    /**
+     * AI configuration for tree generation
+     */
+    aiConfig?: AIConfig;
+    /**
+     * Whether the node actions sheet is open
+     */
+    isNodeSheetOpen: boolean;
+    /**
+     * Function to open or close the node actions sheet
+     */
+    setIsNodeSheetOpen: (open: boolean) => void;
+    /**
+     * ID of the node pending deletion confirmation, or null if no deletion is pending
+     */
+    pendingDeleteNodeId: string | null;
+    /**
+     * Open the deletion confirmation dialog for a given node
+     */
+    openDeleteNodeConfirmation: (id: string) => void;
+    /**
+     * Close the deletion confirmation dialog (cancels any pending deletion)
+     */
+    closeDeleteNodeConfirmation: () => void;
+    /**
+     * Pending node type change that requires user confirmation (when the target type only supports a single outgoing edge).
+     */
+    pendingNodeTypeChange: PendingNodeTypeChange | null;
+    /**
+     * Open the node type change confirmation dialog.
+     */
+    openNodeTypeChangeConfirmation: (payload: PendingNodeTypeChange) => void;
+    /**
+     * Close the node type change confirmation dialog (cancels the pending change).
+     */
+    closeNodeTypeChangeConfirmation: () => void;
+}
+export interface PendingNodeTypeChange {
+    nodeId: string;
+    type: string;
+    subType?: string;
+}
+export interface TreegeEditorRuntimeProviderProps extends PropsWithChildren {
+    value: Omit<TreegeEditorRuntimeContextValue, "isNodeSheetOpen" | "setIsNodeSheetOpen" | "pendingDeleteNodeId" | "openDeleteNodeConfirmation" | "closeDeleteNodeConfirmation" | "pendingNodeTypeChange" | "openNodeTypeChangeConfirmation" | "closeNodeTypeChangeConfirmation">;
+}
+export declare const TreegeEditorRuntimeContext: import('react').Context<TreegeEditorRuntimeContextValue | null>;
+export declare const TreegeEditorRuntimeProvider: ({ children, value }: TreegeEditorRuntimeProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useTreegeEditorRuntime: () => TreegeEditorRuntimeContextValue;

package/dist/editor/features/TreegeEditor/TreegeEditor.d.ts

@@ -1,3 +1,3 @@
 import { TreegeEditorProps } from '../../types/editor';
-declare const TreegeEditor: ({ edges, nodes, flow, onExportJson, onSave, theme, language }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
+declare const TreegeEditor: ({ flow, onExportJson, onSave, onChange, onLanguageChange, aiConfig, extraMenuItems, openApi, baseUrl, onAuthorize, headers, onHeadersChange, language: controlledLanguage, theme, defaultLanguage, }: TreegeEditorProps) => import("react/jsx-runtime").JSX.Element;
 export default TreegeEditor;

package/dist/editor/features/TreegeEditor/controls/MiniMapControl.d.ts

@@ -0,0 +1,6 @@
+interface MiniMapControlProps {
+    show: boolean;
+    onToggle: () => void;
+}
+declare const MiniMapControl: ({ show, onToggle }: MiniMapControlProps) => import("react/jsx-runtime").JSX.Element;
+export default MiniMapControl;

package/dist/editor/features/TreegeEditor/dialogs/AuthorizeDialog.d.ts

@@ -0,0 +1,20 @@
+import { HttpHeaders } from '../../../../shared/types/node';
+interface AuthorizeDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onAuthorize?: (headers: HttpHeaders) => void;
+}
+/**
+ * Reads supported security schemes from the loaded OpenAPI document and
+ * collects credentials from the user (Bearer token, API key value, or
+ * OAuth2 password grant). On submit, exchanges OAuth2 credentials at the
+ * token endpoint, builds the resulting `HttpHeaders`, and calls
+ * `onAuthorize` so the consumer can forward them to the renderer's
+ * global `headers`.
+ *
+ * Inspired by Swagger UI's "Authorize" modal. OAuth2 flows other than
+ * `password` (auth_code, client_credentials, implicit) are out of scope —
+ * they require browser redirects, server-side state, or PKCE.
+ */
+declare const AuthorizeDialog: ({ open, onOpenChange, onAuthorize }: AuthorizeDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default AuthorizeDialog;

package/dist/editor/features/TreegeEditor/dialogs/ChangeNodeTypeDialog.d.ts

@@ -0,0 +1,2 @@
+declare const ChangeNodeTypeDialog: () => import("react/jsx-runtime").JSX.Element;
+export default ChangeNodeTypeDialog;

package/dist/editor/features/TreegeEditor/dialogs/DeleteNodeDialog.d.ts

@@ -0,0 +1,2 @@
+declare const DeleteNodeDialog: () => import("react/jsx-runtime").JSX.Element;
+export default DeleteNodeDialog;

package/dist/editor/features/TreegeEditor/dialogs/HeadersDialog.d.ts

@@ -0,0 +1,19 @@
+import { HttpHeaders } from '../../../../shared/types/node';
+interface HeadersDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    headers: HttpHeaders;
+    onChange: (headers: HttpHeaders) => void;
+}
+/**
+ * Edit the editor's "global headers" — forwarded to every HTTP request the
+ * runtime form issues (HTTP inputs, submit buttons, options-source fetches).
+ * Field-level headers configured on individual nodes override these on key
+ * collision (case-insensitive).
+ *
+ * The dialog is fully controlled: the parent owns the headers list and
+ * receives every mutation via `onChange`, so the same value can be forwarded
+ * to `TreegeRenderer` without any state duplication.
+ */
+declare const HeadersDialog: ({ open, onOpenChange, headers, onChange }: HeadersDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default HeadersDialog;

package/dist/editor/features/TreegeEditor/dialogs/OpenApiDialog.d.ts

@@ -0,0 +1,6 @@
+interface OpenApiDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+declare const OpenApiDialog: ({ open, onOpenChange }: OpenApiDialogProps) => import("react/jsx-runtime").JSX.Element;
+export default OpenApiDialog;

package/dist/editor/features/TreegeEditor/edges/ConditionalEdge.d.ts

@@ -2,5 +2,5 @@ import { Edge, EdgeProps } from '@xyflow/react';
 import { ConditionalEdgeData } from '../../../../shared/types/edge';
 export type ConditionalEdgeType = Edge<ConditionalEdgeData, "conditional">;
 export type ConditionalEdgeProps = EdgeProps<ConditionalEdgeType>;
-declare const ConditionalEdge: ({ id, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element;
-export default ConditionalEdge;
+declare const _default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, }: ConditionalEdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default _default;

package/dist/editor/features/TreegeEditor/edges/DefaultEdge.d.ts

@@ -0,0 +1,3 @@
+import { EdgeProps } from '@xyflow/react';
+declare const _default: import('react').MemoExoticComponent<({ id, source, target, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, style, markerEnd, selected, }: EdgeProps) => import("react/jsx-runtime").JSX.Element | null>;
+export default _default;

package/dist/editor/features/TreegeEditor/forms/HttpConfigForm.d.ts

@@ -1,7 +1,10 @@
+import { ReactNode } from 'react';
 import { HttpConfig } from '../../../../shared/types/node';
 interface HttpConfigFormProps {
     value: HttpConfig | undefined;
     onChange: (config: HttpConfig | undefined) => void;
+    /** Rendered right under the response mapping fields (label/value/description/image). */
+    afterMapping?: ReactNode;
 }
-declare const HttpConfigForm: ({ value, onChange }: HttpConfigFormProps) => import("react/jsx-runtime").JSX.Element;
+declare const HttpConfigForm: ({ value, onChange, afterMapping }: HttpConfigFormProps) => import("react/jsx-runtime").JSX.Element;
 export default HttpConfigForm;

package/dist/editor/features/TreegeEditor/forms/JsonTemplateEditor.d.ts

@@ -0,0 +1,13 @@
+interface FieldRef {
+    nodeId: string;
+    label: string;
+}
+interface JsonTemplateEditorProps {
+    /** The raw JSON template string (source of truth). */
+    value: string;
+    onChange: (next: string) => void;
+    /** Fields that can be bound to a key or value. */
+    fields: FieldRef[];
+}
+declare const JsonTemplateEditor: ({ value, onChange, fields }: JsonTemplateEditorProps) => import("react/jsx-runtime").JSX.Element;
+export default JsonTemplateEditor;

package/dist/editor/features/TreegeEditor/forms/OptionsMappingFields.d.ts

@@ -0,0 +1,34 @@
+import { HttpHeaders, OptionsSourceMapping, QueryParams } from '../../../../shared/types/node';
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export interface OptionsMappingRequest {
+    url?: string;
+    method?: HttpMethod;
+    headers?: HttpHeaders;
+    queryParams?: QueryParams;
+    body?: string;
+    responsePath?: string;
+}
+interface OptionsMappingFieldsProps {
+    /** Request config used by the "Detect fields" button to call the API. */
+    request: OptionsMappingRequest;
+    /** Current field-to-property mapping. */
+    mapping: Partial<OptionsSourceMapping>;
+    /** Called with a partial patch whenever a mapping field changes. */
+    onMappingChange: (patch: Partial<OptionsSourceMapping>) => void;
+    /** When true, also exposes the optional description/image mappings. */
+    showOptionalFields?: boolean;
+}
+/**
+ * Walks the first array item to enumerate field paths usable as mapping keys.
+ * Includes top-level keys and one level of nested object dot-paths.
+ */
+export declare const detectFieldPaths: (response: unknown, responsePath: string) => string[];
+/**
+ * Shared "map response to options" UI: a "Detect fields" button that probes
+ * the configured endpoint to enumerate response field paths, plus the
+ * value/label (and optionally description/image) mapping inputs. Once fields
+ * are detected the inputs become dropdowns of the detected paths. Used by both
+ * the HTTP input config and the dynamic options source so they stay identical.
+ */
+declare const OptionsMappingFields: ({ request, mapping, onMappingChange, showOptionalFields }: OptionsMappingFieldsProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionsMappingFields;

package/dist/editor/features/TreegeEditor/forms/OptionsSourceForm.d.ts

@@ -0,0 +1,7 @@
+import { OptionsSource } from '../../../../shared/types/node';
+interface OptionsSourceFormProps {
+    value: OptionsSource | undefined;
+    onChange: (value: OptionsSource | undefined) => void;
+}
+declare const OptionsSourceForm: ({ value, onChange }: OptionsSourceFormProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionsSourceForm;

package/dist/editor/features/TreegeEditor/forms/SensitiveHeaderWarning.d.ts

@@ -0,0 +1,13 @@
+import { KeyValueEntry } from '../../../../shared/utils/httpRecord';
+interface SensitiveHeaderWarningProps {
+    headers?: KeyValueEntry[];
+}
+/**
+ * Inline alert shown when a field-level header carries credentials (e.g. an
+ * `Authorization` bearer or API key). These headers are persisted in the
+ * exported/saved tree, so the user is nudged toward the non-persisted global
+ * headers (Authorize) for authentication. Renders nothing when no sensitive
+ * header is present.
+ */
+declare const SensitiveHeaderWarning: ({ headers }: SensitiveHeaderWarningProps) => import("react/jsx-runtime").JSX.Element | null;
+export default SensitiveHeaderWarning;

package/dist/editor/features/TreegeEditor/forms/SubmitConfigForm.d.ts

@@ -0,0 +1,7 @@
+import { SubmitConfig } from '../../../../shared/types/node';
+interface SubmitConfigFormProps {
+    value: SubmitConfig | undefined;
+    onChange: (config: SubmitConfig | undefined) => void;
+}
+declare const SubmitConfigForm: ({ value, onChange }: SubmitConfigFormProps) => import("react/jsx-runtime").JSX.Element;
+export default SubmitConfigForm;

package/dist/editor/features/TreegeEditor/inputs/ApiUrlCombobox.d.ts

@@ -0,0 +1,20 @@
+import { ComponentProps, ReactNode } from 'react';
+import { ApiRouteMethod } from '../../../types/openapi';
+import { Input } from '../../../../shared/components/ui/input';
+interface ApiUrlComboboxProps extends Omit<ComponentProps<typeof Input>, "onChange" | "value" | "children"> {
+    value: string;
+    /**
+     * Called whenever the URL changes. When `method` is set, the user picked
+     * a route from the OpenAPI document — callers should also update their
+     * HTTP method state accordingly.
+     */
+    onChange: (url: string, method?: ApiRouteMethod) => void;
+    /**
+     * Optional trailing adornments rendered next to the input (e.g. a variable
+     * picker). Always rendered, regardless of whether an OpenAPI document is
+     * loaded.
+     */
+    children?: ReactNode;
+}
+declare const ApiUrlCombobox: ({ value, onChange, placeholder, children, ...inputProps }: ApiUrlComboboxProps) => import("react/jsx-runtime").JSX.Element;
+export default ApiUrlCombobox;

package/dist/editor/features/TreegeEditor/inputs/ComboboxPattern.d.ts

@@ -1,6 +1,7 @@
 interface ComboboxPatternProps {
     value?: string | null;
     onValueChange?: (newValue: string) => void;
+    id?: string;
 }
-declare const ComboboxPattern: ({ value, onValueChange }: ComboboxPatternProps) => import("react/jsx-runtime").JSX.Element;
+declare const ComboboxPattern: ({ id, value, onValueChange }: ComboboxPatternProps) => import("react/jsx-runtime").JSX.Element;
 export default ComboboxPattern;

package/dist/editor/features/TreegeEditor/inputs/OptionImageField.d.ts

@@ -0,0 +1,6 @@
+interface OptionImageFieldProps {
+    value?: string;
+    onChange: (value: string) => void;
+}
+declare const OptionImageField: ({ value, onChange }: OptionImageFieldProps) => import("react/jsx-runtime").JSX.Element;
+export default OptionImageField;

package/dist/editor/features/TreegeEditor/inputs/SelectNodeGroup.d.ts

@@ -1,2 +1,23 @@
-declare const SelectNodeGroup: () => import("react/jsx-runtime").JSX.Element | null;
+import { TreegeNode } from '../../../../shared/types/node';
+interface SelectNodeGroupProps {
+    /**
+     * Nodes to operate on. When omitted, falls back to the currently selected
+     * node from `useNodesSelection` (preserves the original Sheet behavior).
+     * Pass an array to drive the input from the multi-selection panel; all
+     * mutations (assign / create) are applied to every node in the list.
+     */
+    targetNodes?: TreegeNode[];
+    /**
+     * When true, hides the label above the Select (used by compact panels
+     * where a label would be redundant).
+     */
+    hideLabel?: boolean;
+    /**
+     * Fired after a successful group assignment or creation. Lets the parent
+     * dismiss its surrounding surface (e.g. the badge popover) on commit.
+     * Rename is intentionally excluded — it keeps the surface open.
+     */
+    onChange?: () => void;
+}
+declare const SelectNodeGroup: ({ targetNodes, hideLabel, onChange }?: SelectNodeGroupProps) => import("react/jsx-runtime").JSX.Element | null;
 export default SelectNodeGroup;

package/dist/editor/features/TreegeEditor/layout/AutoLayout.d.ts

@@ -0,0 +1,15 @@
+import { LayoutOptions } from '../../../utils/dagreLayout';
+/**
+ * Keeps the flow laid out automatically using Dagre.
+ *
+ * Runs once all nodes have been measured, then re-runs whenever any node's
+ * measured size changes. Positions computed by Dagre replace the current
+ * `position` of each node — manual repositioning is therefore overridden,
+ * which is the expected behavior for a decision-tree editor where topology
+ * drives layout.
+ *
+ * Group children are laid out independently within their parent, preserving
+ * React Flow's parent-relative coordinate system.
+ */
+declare const AutoLayout: ({ direction, horizontalSpacing, verticalSpacing }?: LayoutOptions) => null;
+export default AutoLayout;

package/dist/editor/features/TreegeEditor/listeners/FlowChangeEmitter.d.ts

@@ -0,0 +1,19 @@
+import { Flow } from '../../../../shared/types/node';
+type FlowChangeEmitterProps = {
+    /** Called (debounced) with the current flow whenever the canvas changes. */
+    onChange?: (flow: Flow) => void;
+    /** Debounce window in ms. @default 150 */
+    debounceMs?: number;
+};
+/**
+ * Emits the current flow (id + nodes + edges) through `onChange` whenever the
+ * canvas changes, debounced. This is the editor's live outbound channel:
+ * unlike Save (gated on having input nodes) it also reports an emptied canvas
+ * after Clear, and unlike Save/Export it does NOT strip sensitive headers,
+ * since live consumers (e.g. the renderer) need the real flow.
+ *
+ * Renders nothing — mount it inside `<ReactFlow>` alongside the canvas, like
+ * `AutoLayout`.
+ */
+declare const FlowChangeEmitter: ({ onChange, debounceMs }: FlowChangeEmitterProps) => null;
+export default FlowChangeEmitter;

package/dist/editor/features/TreegeEditor/nodes/TreegeNode.d.ts

@@ -0,0 +1,5 @@
+import { Node, NodeProps } from '@xyflow/react';
+import { InputNodeData, UINodeData } from '../../../../shared/types/node';
+export type TreegeNodeProps = NodeProps<Node<InputNodeData, "input">> | NodeProps<Node<UINodeData, "ui">>;
+declare const _default: import('react').MemoExoticComponent<(props: TreegeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/editor/features/TreegeEditor/nodes/components/BottomHandleDropdown.d.ts

@@ -0,0 +1,25 @@
+interface BottomHandleDropdownProps {
+    nodeId: string;
+    isConnectable?: boolean;
+    /** Submit nodes / multi-selection: the handle stays in the DOM so edges keep an anchor, but it is invisible and non-interactive. */
+    hidden?: boolean;
+    /** Whether branching (a second outgoing path) is allowed — only for input nodes. */
+    canBranch?: boolean;
+    /**
+     * True when the node sits before a linear successor (stack first/middle). The
+     * controls then reveal on hover (the bottom border overlaps the next node) and
+     * offer "insert between". On a tail (last/single) the controls stay visible.
+     */
+    isJunction?: boolean;
+}
+/**
+ * Bottom-of-node controls anchored on the node's bottom border.
+ *
+ * The branch/add affordance is a real React Flow source `Handle`, so dragging it
+ * goes through the native connection system (cursor line, target snapping, leaf
+ * convergence, `isValidConnection`) — both for adding a child on a tail node and
+ * for branching a new path on a junction node. On junctions an extra "insert
+ * between" button splices a node before the existing successor.
+ */
+declare const BottomHandleDropdown: ({ nodeId, isConnectable, hidden, canBranch, isJunction }: BottomHandleDropdownProps) => import("react/jsx-runtime").JSX.Element;
+export default BottomHandleDropdown;

package/dist/editor/features/TreegeEditor/nodes/components/NodeGroupBadge.d.ts

@@ -0,0 +1,6 @@
+interface NodeGroupBadgeProps {
+    nodeId: string;
+    groupId?: string;
+}
+declare const NodeGroupBadge: ({ nodeId, groupId }: NodeGroupBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeGroupBadge;

package/dist/editor/features/TreegeEditor/nodes/components/NodeImage.d.ts

@@ -0,0 +1,5 @@
+interface NodeImageProps {
+    image?: string;
+}
+declare const NodeImage: ({ image }: NodeImageProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeImage;

package/dist/editor/features/TreegeEditor/nodes/components/NodeImageButton.d.ts

@@ -0,0 +1,6 @@
+interface NodeImageButtonProps {
+    nodeId: string;
+    image?: string;
+}
+declare const NodeImageButton: ({ nodeId, image }: NodeImageButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeImageButton;

package/dist/editor/features/TreegeEditor/nodes/components/NodeInputPreview.d.ts

@@ -0,0 +1,12 @@
+import { InputNodeData } from '../../../../../shared/types/node';
+interface NodeInputPreviewProps {
+    nodeId: string;
+    /**
+     * Input node data. Optional so the parent can pass it unconditionally —
+     * the component returns `null` when undefined or when the runtime renderer
+     * for this input type isn't available.
+     */
+    data?: InputNodeData;
+}
+declare const NodeInputPreview: ({ nodeId, data }: NodeInputPreviewProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeInputPreview;

package/dist/editor/features/TreegeEditor/nodes/components/NodeLabelInput.d.ts

@@ -0,0 +1,10 @@
+import { Translatable } from '../../../../../shared/types/translate';
+interface NodeLabelInputProps {
+    nodeId: string;
+    label?: Translatable;
+    placeholder?: string;
+    className?: string;
+    autoFocus?: boolean;
+}
+declare const NodeLabelInput: ({ nodeId, label, placeholder, className, autoFocus }: NodeLabelInputProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeLabelInput;

package/dist/editor/features/TreegeEditor/nodes/components/NodeMoreMenu.d.ts

@@ -0,0 +1,6 @@
+interface NodeMoreMenuProps {
+    nodeId: string;
+    className?: string;
+}
+declare const NodeMoreMenu: ({ nodeId, className }: NodeMoreMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeMoreMenu;

package/dist/editor/features/TreegeEditor/nodes/components/NodeRequiredButton.d.ts

@@ -0,0 +1,6 @@
+interface NodeRequiredButtonProps {
+    nodeId: string;
+    required?: boolean;
+}
+declare const NodeRequiredButton: ({ nodeId, required }: NodeRequiredButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeRequiredButton;

package/dist/editor/features/TreegeEditor/nodes/components/NodeStackOrderButtons.d.ts

@@ -0,0 +1,6 @@
+interface NodeStackOrderButtonsProps {
+    nodeId: string;
+    selected?: boolean;
+}
+declare const NodeStackOrderButtons: ({ nodeId, selected }: NodeStackOrderButtonsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NodeStackOrderButtons;

package/dist/editor/features/TreegeEditor/nodes/components/NodeTypeBadge.d.ts

@@ -0,0 +1,7 @@
+interface NodeTypeBadgeProps {
+    nodeId: string;
+    nodeType: string;
+    subType?: string;
+}
+declare const NodeTypeBadge: ({ nodeId, nodeType, subType }: NodeTypeBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export default NodeTypeBadge;