windmill-components 1.677.1 → 1.695.0

package/package/components/flows/content/FlowModuleDeleteAfterUse.svelte

@@ -1,19 +1,22 @@
 <script lang="ts">import Toggle from '../../Toggle.svelte';
 import Tooltip from '../../Tooltip.svelte';
+import { SecondsInput } from '../../common';
 import Section from '../../Section.svelte';
 let { flowModule = $bindable(), disabled = false } = $props();
+let enabled = $derived(flowModule.delete_after_secs != null);
 </script>
 
-<Section label="Delete after use">
+<Section label="Delete after completion">
 	{#snippet header()}
 		<Tooltip>
 			The logs, arguments and results of this flow step will be completely deleted from Windmill
-			once the flow is complete. They might be temporarily visible in UI while the flow is running.
+			after the specified delay once the flow is complete. They might be temporarily visible in UI
+			while the flow is running.
 			<br />
 			This also applies to a flow step that has failed: the error will not be accessible.
 			<br />
 			<br />
-			The deletion is irreversible.
+			The deletion is irreversible. Set to 0 for immediate deletion.
 			{#if disabled}
 				<br />
 				<br />
@@ -25,16 +28,21 @@ let { flowModule = $bindable(), disabled = false } = $props();
 	<Toggle
 		{disabled}
 		size="sm"
-		checked={Boolean(flowModule.delete_after_use)}
+		checked={enabled}
 		on:change={() => {
-			if (flowModule.delete_after_use) {
-				flowModule.delete_after_use = undefined
+			if (enabled) {
+				flowModule.delete_after_secs = undefined
 			} else {
-				flowModule.delete_after_use = true
+				flowModule.delete_after_secs = 0
 			}
 		}}
 		options={{
 			right: 'Delete logs, arguments and results after the flow is complete'
 		}}
 	/>
+	{#if enabled}
+		<div class="mt-2">
+			<SecondsInput bind:seconds={flowModule.delete_after_secs} {disabled} size="sm" />
+		</div>
+	{/if}
 </Section>

package/package/components/flows/content/FlowSettings.svelte

@@ -96,6 +96,7 @@ let numberOfAdvancedOptionsOn = $derived(activeAdvancedOptionNames.length);
 						}}
 					/>
 				</Label>
+				<!-- prettier-ignore -->
 				<LabelsInput bind:labels={(flowStore.val as any).labels} class="-mt-4" />
 
 				{#if !noEditor}
@@ -560,6 +561,34 @@ let numberOfAdvancedOptionsOn = $derived(activeAdvancedOptionNames.length);
 					{/snippet}
 				</Toggle>
 
+				<Toggle
+					textClass="font-medium"
+					size="xs"
+					disabled={!$enterpriseLicense}
+					checked={flowStore.val.value.delete_after_secs != null}
+					on:change={() => {
+						if (flowStore.val.value.delete_after_secs != null) {
+							flowStore.val.value.delete_after_secs = undefined
+						} else {
+							flowStore.val.value.delete_after_secs = 0
+						}
+					}}
+					options={{
+						right: 'Delete all step results after completion',
+						rightTooltip: `When enabled, the logs, arguments and results of all flow steps will be deleted after the specified delay once the flow completes. Set to 0 for immediate deletion. The deletion is irreversible. ${!$enterpriseLicense ? 'This is a feature only available on enterprise edition.' : ''}`
+					}}
+					eeOnly={true}
+				/>
+				{#if flowStore.val.value.delete_after_secs != null}
+					<div class="ml-6 mt-1">
+						<SecondsInput
+							bind:seconds={flowStore.val.value.delete_after_secs}
+							disabled={!$enterpriseLicense}
+							size="sm"
+						/>
+					</div>
+				{/if}
+
 				<div>
 					<Toggle
 						textClass="font-medium"

package/package/components/flows/conversations/FlowChatManager.svelte.js

@@ -1,4 +1,4 @@
-import { FlowConversationService, JobService } from '../../../gen';
+import { FlowConversationsService, JobService } from '../../../gen';
 import { sendUserToast } from '../../../toast';
 import { waitJob } from '../../waitJob';
 import { tick } from 'svelte';
@@ -126,7 +126,7 @@ export class FlowChatManager {
     async deleteConversation(conversationId) {
         try {
             this.deletingConversationId = conversationId;
-            await FlowConversationService.deleteFlowConversation({
+            await FlowConversationsService.deleteFlowConversation({
                 workspace: get(workspaceStore),
                 conversationId
             });
@@ -176,7 +176,7 @@ export class FlowChatManager {
         if (!get(workspaceStore) || !this.#path)
             return [];
         try {
-            const response = await FlowConversationService.listFlowConversations({
+            const response = await FlowConversationsService.listFlowConversations({
                 workspace: get(workspaceStore),
                 flowPath: this.#path,
                 page: page,
@@ -208,7 +208,7 @@ export class FlowChatManager {
         const pageToFetch = reset ? 1 : this.page + 1;
         try {
             const previousScrollHeight = this.messagesContainer?.scrollHeight || 0;
-            const response = await FlowConversationService.listConversationMessages({
+            const response = await FlowConversationsService.listConversationMessages({
                 workspace: get(workspaceStore),
                 conversationId: conversationIdToUse,
                 page: pageToFetch,
@@ -266,6 +266,15 @@ export class FlowChatManager {
             messageElement.scrollIntoView({ behavior: 'smooth', block: 'start' });
         }
     }
+    getLastPersistedMessageSeq() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const message = this.messages[i];
+            if (!message.id.startsWith('temp-')) {
+                return message.created_seq;
+            }
+        }
+        return undefined;
+    }
     // Polling
     async pollJobResult(jobId) {
         try {
@@ -291,19 +300,18 @@ export class FlowChatManager {
         if (!get(workspaceStore))
             return;
         try {
-            const lastId = this.messages[this.messages.length - 1].id;
-            const response = await FlowConversationService.listConversationMessages({
+            const lastSeq = this.getLastPersistedMessageSeq();
+            const response = await FlowConversationsService.listConversationMessages({
                 workspace: get(workspaceStore),
                 conversationId: conversationId,
                 page: 1,
                 perPage: 50,
-                afterId: lastId
+                afterSeq: lastSeq
             });
             if (options?.isNewConversation) {
                 await this.refreshConversations();
             }
             const filteredResponse = response.filter((msg) => msg.message_type !== 'user');
-            // Add any new intermediate messages not already present
             for (const msg of filteredResponse) {
                 if (!this.messages.find((m) => m.id === msg.id)) {
                     this.messages = [...this.messages, msg];
@@ -312,7 +320,7 @@ export class FlowChatManager {
             // Only remove temporary messages when explicitly requested (e.g., after job completion)
             // During streaming, we keep temp messages to avoid them disappearing due to race conditions
             if (options?.removeTempMessages) {
-                this.messages = this.messages.filter((msg) => !msg.id.startsWith('temp-'));
+                this.messages = this.messages.filter((msg) => !msg.id.startsWith('temp-') || msg.message_type === 'user');
             }
         }
         catch (error) {
@@ -355,9 +363,10 @@ export class FlowChatManager {
         // Invalidate the conversation cache
         delete this.#conversationsCache[currentConversationId];
         const userMessage = {
-            id: randomUUID(),
+            id: `temp-${randomUUID()}`,
             content: this.inputMessage.trim(),
             created_at: new Date().toISOString(),
+            created_seq: 0,
             message_type: 'user',
             conversation_id: currentConversationId
         };
@@ -470,6 +479,7 @@ export class FlowChatManager {
                                         id: 'temp-' + randomUUID(),
                                         content: newContent,
                                         created_at: new Date().toISOString(),
+                                        created_seq: 0,
                                         message_type: 'tool',
                                         conversation_id: currentConversationId,
                                         job_id: '',
@@ -493,6 +503,7 @@ export class FlowChatManager {
                                         id: assistantMessageId,
                                         content: accumulatedContent,
                                         created_at: new Date().toISOString(),
+                                        created_seq: 0,
                                         message_type: 'assistant',
                                         conversation_id: currentConversationId,
                                         job_id: '',

package/package/components/flows/dfs.d.ts

@@ -1,4 +1,8 @@
 import type { FlowModule } from '../../gen';
-export declare function dfs<T>(modules: FlowModule[], f: (x: FlowModule, modules: FlowModule[], branches: FlowModule[][]) => T, opts?: {
+type FlowDfsOptions = {
     skipToolNodes?: boolean;
-}): T[];
+};
+type FlowModuleVisitor<T> = (x: FlowModule, modules: FlowModule[], branches: FlowModule[][]) => T;
+export declare function dfs<T>(modules: FlowModule[], f: FlowModuleVisitor<T>, opts?: FlowDfsOptions): T[];
+export declare function forEachFlowModule(modules: FlowModule[], f: FlowModuleVisitor<void>, opts?: FlowDfsOptions): void;
+export {};

package/package/components/flows/dfs.js

@@ -1,31 +1,39 @@
-export function dfs(modules, f, opts = {}) {
-    let result = [];
+function traverseFlowModules(modules, visit, opts = {}) {
     for (const module of modules) {
         if (module.value.type == 'forloopflow' || module.value.type == 'whileloopflow') {
-            result = result.concat(f(module, modules, [module.value.modules]));
-            result = result.concat(dfs(module.value.modules, f, opts));
+            visit(module, modules, [module.value.modules]);
+            traverseFlowModules(module.value.modules, visit, opts);
         }
         else if (module.value.type == 'branchone') {
             const allBranches = [module.value.default, ...module.value.branches.map((b) => b.modules)];
-            result = result.concat(f(module, modules, allBranches));
+            visit(module, modules, allBranches);
             for (const branch of allBranches) {
-                result = result.concat(dfs(branch, f, opts));
+                traverseFlowModules(branch, visit, opts);
             }
         }
         else if (module.value.type == 'branchall') {
             const allBranches = module.value.branches.map((b) => b.modules);
-            result = result.concat(f(module, modules, allBranches));
+            visit(module, modules, allBranches);
             for (const branch of allBranches) {
-                result = result.concat(dfs(branch, f, opts));
+                traverseFlowModules(branch, visit, opts);
             }
         }
         else if (module.value.type == 'aiagent' && !opts.skipToolNodes) {
-            result = result.concat(f(module, modules, [module.value.tools]));
-            result = result.concat(dfs(module.value.tools, f, opts));
+            visit(module, modules, [module.value.tools]);
+            traverseFlowModules(module.value.tools, visit, opts);
         }
         else {
-            result.push(f(module, modules, []));
+            visit(module, modules, []);
         }
     }
+}
+export function dfs(modules, f, opts = {}) {
+    let result = [];
+    traverseFlowModules(modules, (module, parentModules, branches) => {
+        result.push(f(module, parentModules, branches));
+    }, opts);
     return result;
 }
+export function forEachFlowModule(modules, f, opts = {}) {
+    traverseFlowModules(modules, f, opts);
+}

package/package/components/flows/flowDeleteController.d.ts

@@ -0,0 +1,32 @@
+import type { GroupDisplayState } from '../graph/groupEditor.svelte';
+import type { GroupedModulesProxy } from '../graph/groupedModulesProxy.svelte';
+import type { SelectionManager } from '../graph/selectionUtils.svelte';
+import type { FlowStructureNode } from '../graph/flowStructure';
+import type { OpenFlow } from '../../gen';
+import { type History } from '../../history.svelte';
+import type { StateStore } from '../../utils';
+import { type DeletePlan } from './flowDeleteUtils';
+import type { FlowState } from './flowState';
+export type PreparedDeleteRequest = {
+    plan: DeletePlan;
+    needsDependencyConfirmation: boolean;
+};
+export type DeletePlanExecutionContext = {
+    history?: History<OpenFlow>;
+    flowStore: StateStore<OpenFlow>;
+    flowStateStore: StateStore<FlowState>;
+    selectionManager: Pick<SelectionManager, 'clearSelection' | 'selectId'>;
+    onDelete?: (id: string) => void;
+};
+export type DeletePlanExecutionResult = {
+    removedStateIds: string[];
+    removedToolStateIds: string[];
+};
+export declare function prepareDeleteRequest(args: {
+    ids: string[];
+    flow: OpenFlow;
+    tree: FlowStructureNode[];
+    proxy: GroupedModulesProxy;
+    displayState: GroupDisplayState;
+}): PreparedDeleteRequest | undefined;
+export declare function executeDeletePlan(plan: DeletePlan, args: DeletePlanExecutionContext): DeletePlanExecutionResult;

package/package/components/flows/flowDeleteController.js

@@ -0,0 +1,54 @@
+import { push } from '../../history.svelte';
+import { refreshStateStore } from '../../svelte5Utils.svelte';
+import { createDeletePlan, removeDeletePlanTools } from './flowDeleteUtils';
+import { deleteFlowStateById } from './flowStateUtils.svelte';
+export function prepareDeleteRequest(args) {
+    const plan = createDeletePlan(args);
+    if (!plan) {
+        return undefined;
+    }
+    return {
+        plan,
+        needsDependencyConfirmation: Object.keys(plan.dependents).length > 0
+    };
+}
+export function executeDeletePlan(plan, args) {
+    push(args.history, args.flowStore.val);
+    const removedStructureStateIds = resolvePlannedStructureStateIds(plan.targets);
+    if (plan.selection.kind === 'clear') {
+        args.selectionManager.clearSelection();
+    }
+    else {
+        args.selectionManager.selectId(plan.selection.id);
+    }
+    if (plan.targets.some((target) => target.kind === 'preprocessor')) {
+        args.flowStore.val.value.preprocessor_module = undefined;
+    }
+    plan.structureDelete?.commit({ removeDuplicates: plan.removeDuplicates });
+    const removedToolStateIds = removeDeletePlanTools(plan.targets, args.flowStore.val.value.modules);
+    const removedStateIds = uniqueIds([...removedStructureStateIds, ...removedToolStateIds]);
+    for (const id of removedStateIds) {
+        deleteFlowStateById(id, args.flowStateStore);
+    }
+    refreshStateStore(args.flowStore);
+    if (plan.inputIds.length === 1) {
+        args.onDelete?.(plan.targets[0].id);
+    }
+    return {
+        removedStateIds,
+        removedToolStateIds
+    };
+}
+function resolvePlannedStructureStateIds(targets) {
+    const removedIds = [];
+    for (const target of targets) {
+        if (target.kind !== 'preprocessor' && target.kind !== 'structure_node') {
+            continue;
+        }
+        removedIds.push(...target.stateIds);
+    }
+    return uniqueIds(removedIds);
+}
+function uniqueIds(ids) {
+    return [...new Set(ids)];
+}

package/package/components/flows/flowDeleteController.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/flows/flowDeleteController.test.js

@@ -0,0 +1,121 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('../aiProviderStorage', () => ({
+    loadStoredConfig: () => undefined
+}));
+vi.mock('./flowInfers', () => ({
+    AI_AGENT_SCHEMA: { properties: {} }
+}));
+import { GroupDisplayState } from '../graph/groupEditor.svelte';
+import { GroupedModulesProxy } from '../graph/groupedModulesProxy.svelte';
+import { executeDeletePlan, prepareDeleteRequest } from './flowDeleteController';
+function makeRawModule(id, expr) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'rawscript',
+            content: '',
+            language: 'python3',
+            input_transforms: expr
+                ? {
+                    user_input: {
+                        type: 'javascript',
+                        expr
+                    }
+                }
+                : {}
+        }
+    };
+}
+function makeAiAgent(id, tools) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
+function makeFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+describe('flowDeleteController', () => {
+    it('prepares confirmations and executes grouped ai-agent deletes end to end', () => {
+        const agent = makeAiAgent('agent_step', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const dependent = makeRawModule('dependent_step', 'results.create_ticket?.value');
+        const flowStore = {
+            val: {
+                summary: 'Flow',
+                value: {
+                    modules: [agent, dependent],
+                    groups: [
+                        {
+                            summary: 'Agent group',
+                            start_id: 'agent_step',
+                            end_id: 'agent_step'
+                        }
+                    ]
+                }
+            }
+        };
+        const proxy = new GroupedModulesProxy(flowStore);
+        const displayState = new GroupDisplayState(() => flowStore.val.value.groups ?? []);
+        const request = prepareDeleteRequest({
+            ids: ['agent_step'],
+            flow: flowStore.val,
+            tree: proxy.items,
+            proxy,
+            displayState
+        });
+        expect(request?.needsDependencyConfirmation).toBe(true);
+        expect(request?.plan.structureDelete?.affectedGroups).toHaveLength(1);
+        expect(request?.plan.structureDelete?.affectedGroups[0]).toMatchObject({
+            summary: 'Agent group',
+            start_id: 'agent_step',
+            end_id: 'agent_step'
+        });
+        const selectionManager = {
+            clearSelection: vi.fn(),
+            selectId: vi.fn()
+        };
+        const flowStateStore = {
+            val: {
+                agent_step: {},
+                lookup_user: {},
+                support_agent: {},
+                create_ticket: {},
+                dependent_step: {}
+            }
+        };
+        const onDelete = vi.fn();
+        const result = executeDeletePlan(request.plan, {
+            flowStore,
+            flowStateStore,
+            selectionManager,
+            onDelete
+        });
+        expect(result.removedStateIds).toEqual([
+            'agent_step',
+            'lookup_user',
+            'support_agent',
+            'create_ticket'
+        ]);
+        expect(flowStore.val.value.modules.map((module) => module.id)).toEqual(['dependent_step']);
+        expect(flowStore.val.value.groups ?? []).toEqual([]);
+        expect(Object.keys(flowStateStore.val)).toEqual(['dependent_step']);
+        expect(selectionManager.selectId).toHaveBeenCalledWith('dependent_step');
+        expect(onDelete).toHaveBeenCalledWith('agent_step');
+    });
+});

package/package/components/flows/flowDeleteUtils.d.ts

@@ -0,0 +1,48 @@
+import type { GroupDisplayState } from '../graph/groupEditor.svelte';
+import type { GroupedModulesProxy, PreparedStructureDelete } from '../graph/groupedModulesProxy.svelte';
+import { type FlowStructureNode } from '../graph/flowStructure';
+import type { FlowModule, OpenFlow } from '../../gen';
+import type { AgentTool } from './agentToolUtils';
+export type DeleteSelection = {
+    kind: 'clear';
+} | {
+    kind: 'select';
+    id: string;
+};
+type DeleteTargetBase = {
+    id: string;
+    stateIds: string[];
+};
+export type PreprocessorDeleteTarget = DeleteTargetBase & {
+    kind: 'preprocessor';
+};
+export type StructureDeleteTarget = DeleteTargetBase & {
+    kind: 'structure_node';
+};
+export type AgentToolDeleteTarget = DeleteTargetBase & {
+    kind: 'agent_tool';
+};
+export type DeleteTarget = PreprocessorDeleteTarget | StructureDeleteTarget | AgentToolDeleteTarget;
+export type DeletePlan = {
+    inputIds: string[];
+    targets: DeleteTarget[];
+    plannedStateIds: string[];
+    dependents: Record<string, string[]>;
+    selection: DeleteSelection;
+    structureDelete?: PreparedStructureDelete;
+    removeDuplicates: boolean;
+};
+export type ResolvedDeleteTargets = {
+    targets: DeleteTarget[];
+    missingIds: string[];
+};
+export declare function resolveDeleteTargets(tree: FlowStructureNode[], modules: FlowModule[], ids: string[], hasPreprocessor: boolean): ResolvedDeleteTargets;
+export declare function createDeletePlan(args: {
+    ids: string[];
+    flow: OpenFlow;
+    tree: FlowStructureNode[];
+    proxy: GroupedModulesProxy;
+    displayState: GroupDisplayState;
+}): DeletePlan | undefined;
+export declare function removeDeletePlanTools(targets: DeleteTarget[], modules: FlowModule[], onRemove?: (tool: AgentTool) => void): string[];
+export {};

package/package/components/flows/flowDeleteUtils.js

@@ -0,0 +1,150 @@
+import { findInStructure } from '../graph/flowStructure';
+import { collectAgentToolIds, collectFlowNodeIds, findAgentToolOwner, removeAgentToolOwner } from './agentToolTree';
+import { dfs } from './dfs';
+import { getDependentComponents } from './flowExplorer';
+import { findModuleInModules } from './flowTree';
+export function resolveDeleteTargets(tree, modules, ids, hasPreprocessor) {
+    const targets = [];
+    const missingIds = [];
+    const seenIds = new Set();
+    for (const id of ids) {
+        if (seenIds.has(id)) {
+            continue;
+        }
+        seenIds.add(id);
+        if (id === 'preprocessor') {
+            if (hasPreprocessor) {
+                targets.push({ kind: 'preprocessor', id, stateIds: [id] });
+            }
+            else {
+                missingIds.push(id);
+            }
+            continue;
+        }
+        if (findInStructure(tree, id)) {
+            const module = findModuleInModules(modules, id);
+            if (module) {
+                targets.push({
+                    kind: 'structure_node',
+                    id,
+                    stateIds: collectFlowNodeIds(module)
+                });
+                continue;
+            }
+        }
+        const owner = findAgentToolOwner(modules, id);
+        if (owner) {
+            targets.push({
+                kind: 'agent_tool',
+                id,
+                stateIds: collectAgentToolIds(owner.tool)
+            });
+            continue;
+        }
+        missingIds.push(id);
+    }
+    return {
+        targets: pruneNestedTargets(targets),
+        missingIds
+    };
+}
+export function createDeletePlan(args) {
+    const { targets } = resolveDeleteTargets(args.tree, args.flow.value.modules, args.ids, Boolean(args.flow.value.preprocessor_module));
+    if (targets.length === 0) {
+        return undefined;
+    }
+    const structureIds = targets
+        .filter((target) => target.kind === 'structure_node')
+        .map((target) => target.id);
+    const structureDelete = structureIds.length > 0
+        ? args.proxy.prepareDelete(structureIds, { displayState: args.displayState })
+        : undefined;
+    const plannedStateIds = uniqueIds(targets.flatMap((target) => target.stateIds));
+    return {
+        inputIds: args.ids,
+        targets,
+        plannedStateIds,
+        dependents: collectDeleteDependents(plannedStateIds, args.flow),
+        selection: getDeleteSelection(args.ids, plannedStateIds, args.flow.value.modules),
+        structureDelete,
+        removeDuplicates: Boolean(structureDelete?.duplicateGroups.length)
+    };
+}
+export function removeDeletePlanTools(targets, modules, onRemove) {
+    const removedIds = new Set();
+    const toolTargets = targets
+        .filter((target) => target.kind === 'agent_tool')
+        .map((target) => findAgentToolOwner(modules, target.id))
+        .filter((owner) => Boolean(owner))
+        .sort((left, right) => {
+        if (left.depth !== right.depth) {
+            return right.depth - left.depth;
+        }
+        if (left.tools === right.tools) {
+            return right.toolIndex - left.toolIndex;
+        }
+        return 0;
+    });
+    for (const owner of toolTargets) {
+        const removed = removeAgentToolOwner(owner);
+        if (!removed) {
+            continue;
+        }
+        onRemove?.(removed.tool);
+        for (const id of removed.removedIds) {
+            removedIds.add(id);
+        }
+    }
+    return [...removedIds];
+}
+function pruneNestedTargets(targets) {
+    const descendantIds = new Set();
+    for (const target of targets) {
+        for (const stateId of target.stateIds) {
+            if (stateId !== target.id) {
+                descendantIds.add(stateId);
+            }
+        }
+    }
+    return targets.filter((target) => !descendantIds.has(target.id));
+}
+function collectDeleteDependents(ids, flow) {
+    const deletingSet = new Set(ids);
+    const dependents = {};
+    for (const id of ids) {
+        const dependencies = getDependentComponents(id, flow);
+        for (const [dependentId, expressions] of Object.entries(dependencies)) {
+            if (deletingSet.has(dependentId)) {
+                continue;
+            }
+            dependents[dependentId] = [...(dependents[dependentId] ?? []), ...expressions];
+        }
+    }
+    return dependents;
+}
+function getDeleteSelection(ids, deletedIds, modules) {
+    if (ids.length !== 1) {
+        return { kind: 'clear' };
+    }
+    const [id] = ids;
+    if (id === 'preprocessor') {
+        return { kind: 'select', id: 'Input' };
+    }
+    const orderedIds = dfs(modules, (module) => module.id);
+    const index = orderedIds.indexOf(id);
+    const deletedSet = new Set(deletedIds);
+    for (let i = index - 1; i >= 0; i--) {
+        if (!deletedSet.has(orderedIds[i])) {
+            return { kind: 'select', id: orderedIds[i] };
+        }
+    }
+    for (let i = index + 1; i < orderedIds.length; i++) {
+        if (!deletedSet.has(orderedIds[i])) {
+            return { kind: 'select', id: orderedIds[i] };
+        }
+    }
+    return { kind: 'select', id: 'settings-metadata' };
+}
+function uniqueIds(ids) {
+    return [...new Set(ids)];
+}

package/package/components/flows/flowDeleteUtils.test.d.ts

@@ -0,0 +1 @@
+export {};