windmill-components 1.208.0 → 1.216.0

package/package/components/Editor.svelte

@@ -17,7 +17,7 @@ import { MonacoLanguageClient } from 'monaco-languageclient';
 import { toSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode-ws-jsonrpc';
 import { CloseAction, ErrorAction, RequestType, NotificationType } from 'vscode-languageclient';
 import { MonacoBinding } from 'y-monaco';
-import { dbSchemas, copilotInfo } from '../stores';
+import { dbSchemas, copilotInfo, codeCompletionSessionEnabled } from '../stores';
 import { createHash as randomHash, editorConfig, langToExt, updateOptions } from '../editorUtils';
 import { buildWorkerDefinition } from './build_workers';
 import { workspaceStore } from '../stores';
@@ -181,14 +181,22 @@ export async function format() {
 }
 let command = undefined;
 let sqlSchemaCompletor = undefined;
-function updateSchema(lang, args) {
-    const schemaRes = lang === 'graphql' ? args.api : args.database;
-    if (typeof schemaRes === 'string') {
-        dbSchema = $dbSchemas[schemaRes.replace('$res:', '')];
+let oldSchemaRes = '';
+function updateSchema() {
+    const newSchemaRes = lang === 'graphql' ? args?.api : args?.database;
+    if (typeof newSchemaRes === 'string') {
+        const newSchema = $dbSchemas[newSchemaRes.replace('$res:', '')];
+        if (newSchema && newSchemaRes !== oldSchemaRes) {
+            oldSchemaRes = newSchemaRes;
+            dbSchema = newSchema;
+            return;
+        }
     }
+    dbSchema = undefined;
+    oldSchemaRes = '';
 }
-$: args && updateSchema(lang, args);
-$: dbSchema && ['sql', 'graphql'].includes(lang) && addDBSchemaCompletions();
+$: lang && args && $dbSchemas && updateSchema();
+$: initialized && dbSchema && ['sql', 'graphql'].includes(lang) && addDBSchemaCompletions();
 $: (!dbSchema || lang !== 'sql') && sqlSchemaCompletor && sqlSchemaCompletor.dispose();
 $: (!dbSchema || lang !== 'graphql') && graphqlService && graphqlService.setSchemaConfig([]);
 function addDBSchemaCompletions() {
@@ -305,6 +313,9 @@ function addCopilotSuggestions() {
                 if (copilotTs === thisTs) {
                     abortController?.abort();
                     abortController = new AbortController();
+                    token.onCancellationRequested(() => {
+                        abortController?.abort();
+                    });
                     const insertText = await editorCodeCompletion(textUntilPosition, textAfterPosition, lang, abortController);
                     if (insertText) {
                         items = [
@@ -325,8 +336,10 @@ function addCopilotSuggestions() {
 }
 $: $copilotInfo.exists_openai_resource_path &&
     $copilotInfo.code_completion_enabled &&
+    $codeCompletionSessionEnabled &&
     initialized &&
     addCopilotSuggestions();
+$: !$codeCompletionSessionEnabled && copilotCompletor && copilotCompletor.dispose();
 const outputChannel = {
     name: 'Language Server Client',
     appendLine: (msg) => {
@@ -708,7 +721,7 @@ $: if (yContent && awareness && modelRef && editor) {
 let initialized = false;
 async function loadMonaco() {
     try {
-        console.error("Loading Monaco's language client");
+        console.log("Loading Monaco's language client");
         await initializeVscode();
     }
     catch (e) {

package/package/components/EditorBar.svelte

@@ -24,6 +24,7 @@ import { capitalize, toCamel } from '../utils';
 import ScriptVersionHistory from './ScriptVersionHistory.svelte';
 import ScriptGen from './copilot/ScriptGen.svelte';
 import { getResetCode } from '../script_helpers';
+import CodeCompletionStatus from './copilot/CodeCompletionStatus.svelte';
 export let lang;
 export let editor;
 export let websocketAlive;
@@ -502,6 +503,8 @@ let historyBrowserDrawerOpen = false;
 
 			<ScriptGen {editor} {diffEditor} {lang} {iconOnly} {args} />
 
+			<CodeCompletionStatus />
+
 			<!-- <Popover
 				notClickable
 				placement="bottom"

package/package/components/ErrorOrRecoveryHandler.svelte

@@ -4,7 +4,7 @@ import ScriptPicker from './ScriptPicker.svelte';
 import Toggle from './Toggle.svelte';
 import { enterpriseLicense, workspaceStore } from '../stores';
 import { emptySchema, emptyString, sendUserToast, tryEvery } from '../utils';
-import { JobService, Script, ScriptService, WorkspaceService } from '../gen';
+import { FlowService, JobService, Script, ScriptService, WorkspaceService } from '../gen';
 import { inferArgs } from '../infer';
 import { CheckCircle2, Loader2, RotateCw, XCircle } from 'lucide-svelte';
 const slackRecoveryHandler = 'hub/2430/slack/schedule-recovery-handler-slack';
@@ -75,6 +75,7 @@ async function sendSlackMessage(channel) {
     });
 }
 async function loadHandlerScriptArgs(p, defaultArgs = []) {
+    console.log(p);
     try {
         let schema = emptySchema();
         if (p.startsWith('hub/')) {
@@ -89,8 +90,10 @@ async function loadHandlerScriptArgs(p, defaultArgs = []) {
             }
         }
         else {
-            const script = await ScriptService.getScriptByPath({ workspace: $workspaceStore, path: p });
-            schema = script.schema;
+            let scriptOrFlow = customHandlerKind === 'script'
+                ? await ScriptService.getScriptByPath({ workspace: $workspaceStore, path: p })
+                : await FlowService.getFlowByPath({ workspace: $workspaceStore, path: p });
+            schema = scriptOrFlow.schema;
         }
         if (schema && schema.properties) {
             for (let key in schema.properties) {

package/package/components/FlowBuilder.svelte

@@ -23,7 +23,7 @@ import { stepCopilot, glueCopilot } from './copilot/flow';
 import FlowCopilotDrawer from './copilot/FlowCopilotDrawer.svelte';
 import FlowCopilotStatus from './copilot/FlowCopilotStatus.svelte';
 import { fade } from 'svelte/transition';
-import { loadFlowModuleState } from './flows/flowStateUtils';
+import { loadFlowModuleState, pickScript } from './flows/flowStateUtils';
 import FlowCopilotInputsModal from './copilot/FlowCopilotInputsModal.svelte';
 import { snakeCase } from 'lodash';
 import FlowBuilderTutorials from './FlowBuilderTutorials.svelte';
@@ -168,33 +168,19 @@ async function saveFlow() {
         }
         else {
             localStorage.removeItem(`flow-${initialPath}`);
-            await FlowService.updateFlow({
-                workspace: $workspaceStore,
-                path: initialPath,
-                requestBody: {
-                    path: $pathStore,
-                    summary: flow.summary,
-                    description: flow.description ?? '',
-                    value: flow.value,
-                    schema: flow.schema,
-                    tag: flow.tag,
-                    dedicated_worker: flow.dedicated_worker,
-                    ws_error_handler_muted: flow.ws_error_handler_muted
-                }
-            });
             const scheduleExists = await ScheduleService.existsSchedule({
                 workspace: $workspaceStore ?? '',
-                path: $pathStore
+                path: initialPath
             });
             if (scheduleExists) {
                 const schedule = await ScheduleService.getSchedule({
                     workspace: $workspaceStore ?? '',
-                    path: $pathStore
+                    path: initialPath
                 });
                 if (JSON.stringify(schedule.args) != JSON.stringify(args) || schedule.schedule != cron) {
                     await ScheduleService.updateSchedule({
                         workspace: $workspaceStore ?? '',
-                        path: $pathStore,
+                        path: initialPath,
                         requestBody: {
                             schedule: formatCron(cron),
                             timezone,
@@ -205,14 +191,28 @@ async function saveFlow() {
                 if (enabled != schedule.enabled) {
                     await ScheduleService.setScheduleEnabled({
                         workspace: $workspaceStore ?? '',
-                        path: $pathStore,
+                        path: initialPath,
                         requestBody: { enabled }
                     });
                 }
             }
             else if (enabled) {
-                await createSchedule($pathStore);
+                await createSchedule(initialPath);
             }
+            await FlowService.updateFlow({
+                workspace: $workspaceStore,
+                path: initialPath,
+                requestBody: {
+                    path: $pathStore,
+                    summary: flow.summary,
+                    description: flow.description ?? '',
+                    value: flow.value,
+                    schema: flow.schema,
+                    tag: flow.tag,
+                    dedicated_worker: flow.dedicated_worker,
+                    ws_error_handler_muted: flow.ws_error_handler_muted
+                }
+            });
         }
         savedFlow = {
             ...cloneDeep($flowStore),
@@ -367,10 +367,11 @@ let flowCopilotContext = {
     drawerStore: writable(undefined),
     modulesStore: writable([]),
     currentStepStore: writable(undefined),
-    genFlow: undefined
+    genFlow: undefined,
+    shouldUpdatePropertyType: writable({})
 };
 setContext('FlowCopilotContext', flowCopilotContext);
-const { drawerStore: copilotDrawerStore, modulesStore: copilotModulesStore, currentStepStore: copilotCurrentStepStore } = flowCopilotContext;
+const { drawerStore: copilotDrawerStore, modulesStore: copilotModulesStore, currentStepStore: copilotCurrentStepStore, shouldUpdatePropertyType } = flowCopilotContext;
 let doneTs = 0;
 async function getHubCompletions(text, idx, type) {
     try {
@@ -382,8 +383,7 @@ async function getHubCompletions(text, idx, type) {
             kind: type
         })).map((s) => ({
             ...s,
-            path: `hub/${s.version_id}/${s.app}/${s.summary.toLowerCase().replaceAll(/\s+/g, '_')}`,
-            summary: `${s.summary} (${s.app})`
+            path: `hub/${s.version_id}/${s.app}/${s.summary.toLowerCase().replaceAll(/\s+/g, '_')}`
         }));
         if (ts < doneTs)
             return;
@@ -445,7 +445,7 @@ function applyCopilotFlowInputs() {
 }
 function clearFlowInputsFromStep(id) {
     const module = dfs(id, $flowStore)[0];
-    if (module?.value.type === 'rawscript') {
+    if (module?.value.type === 'rawscript' || module?.value.type === 'script') {
         // clear step inputs that start with flow_input. but not flow_input.iter
         for (const key in module.value.input_transforms) {
             const input = module.value.input_transforms[key];
@@ -456,6 +456,7 @@ function clearFlowInputsFromStep(id) {
                     type: 'static',
                     value: undefined
                 };
+                $shouldUpdatePropertyType[key] = 'static';
             }
         }
     }
@@ -498,12 +499,6 @@ async function genFlow(idx, flowModules, stepOnly = false) {
             }
             $scheduleStore.enabled = true;
         }
-        let hubScript = undefined;
-        if (module.source === 'hub' && module.selectedCompletion) {
-            hubScript = await ScriptService.getHubScriptByPath({
-                path: module.selectedCompletion.path
-            });
-        }
         const flowModule = {
             id: module.id,
             stop_after_if: module.type === 'trigger'
@@ -515,12 +510,22 @@ async function genFlow(idx, flowModules, stepOnly = false) {
             value: {
                 input_transforms: {},
                 content: '',
-                language: (hubScript ? hubScript.language : module.lang ?? 'bun'),
+                language: (module.lang ?? 'bun'),
                 type: 'rawscript'
             },
-            summary: module.selectedCompletion?.summary ?? module.description
+            summary: module.description
         };
-        $flowStateStore[module.id] = emptyFlowModuleState();
+        let isHubStep = false;
+        if (module.source === 'hub' && module.selectedCompletion) {
+            isHubStep = true;
+            const [hubScriptModule, hubScriptState] = await pickScript(module.selectedCompletion.path, `${module.selectedCompletion.summary} (${module.selectedCompletion.app})`, module.id, undefined);
+            flowModule.value = hubScriptModule.value;
+            flowModule.summary = hubScriptModule.summary;
+            $flowStateStore[module.id] = hubScriptState;
+        }
+        else {
+            $flowStateStore[module.id] = emptyFlowModuleState();
+        }
         if (stepOnly) {
             flowModules.splice(idx, 0, flowModule);
         }
@@ -545,6 +550,7 @@ async function genFlow(idx, flowModules, stepOnly = false) {
             flowModules.push(flowModule);
         }
         $copilotDrawerStore?.closeDrawer();
+        await tick();
         select(module.id);
         await tick();
         await tick();
@@ -557,45 +563,59 @@ async function genFlow(idx, flowModules, stepOnly = false) {
         }
         const prevNodeId = getPreviousIds(module.id, $flowStore, false)[0];
         const pastModule = dfs(prevNodeId, $flowStore, false)[0];
-        if (hubScript) {
-            module.editor?.setCode(hubScript.content);
+        if (!module.source) {
+            throw new Error('Invalid copilot module source');
         }
-        else if (module.source === 'custom') {
+        if (module.source === 'custom') {
             const deltaStore = writable('');
             const unsubscribe = deltaStore.subscribe(async (delta) => {
                 module.editor?.append(delta);
             });
             abortController = new AbortController();
-            await stepCopilot(module, deltaStore, pastModule?.value.type === 'rawscript' ? pastModule.value.content : '', pastModule?.value.type === 'rawscript' ? pastModule.value.language : undefined, pastModule === undefined, isFirstInLoop, abortController);
+            await stepCopilot(module, deltaStore, $workspaceStore, pastModule?.value.type === 'rawscript' || pastModule?.value.type === 'script'
+                ? pastModule
+                : undefined, isFirstInLoop, abortController);
             unsubscribe();
         }
-        else {
-            throw new Error('Invalid copilot module source');
-        }
         copilotStatus = "Generating inputs for step '" + module.id + "'...";
         await sleep(500); // make sure code was parsed
         try {
-            if (flowModule.value.type === 'rawscript') {
+            if ((flowModule.value.type === 'rawscript' || flowModule.value.type === 'script') &&
+                (pastModule === undefined ||
+                    pastModule.value.type === 'rawscript' ||
+                    pastModule.value.type === 'script')) {
                 const stepSchema = JSON.parse(JSON.stringify($flowStateStore[module.id].schema)); // deep copy
-                if (module.source === 'hub' &&
-                    pastModule !== undefined &&
-                    $copilotInfo.exists_openai_resource_path) {
+                if (isHubStep && pastModule !== undefined && $copilotInfo.exists_openai_resource_path) {
                     // ask AI to set step inputs
                     abortController = new AbortController();
-                    const inputs = await glueCopilot(Object.keys(flowModule.value.input_transforms), pastModule.value.type === 'rawscript' ? pastModule.value.content : '', pastModule.value.type === 'rawscript' ? pastModule.value.language : undefined, isFirstInLoop, abortController);
+                    const { inputs, allExprs } = await glueCopilot(flowModule.value.input_transforms, $workspaceStore, pastModule, isFirstInLoop, abortController);
                     // create flow inputs used by AI for autocompletion
                     copilotFlowInputs = {};
                     copilotFlowRequiredInputs = [];
-                    Object.entries(inputs).forEach(([key, expr]) => {
-                        const snakeKey = snakeCase(key);
-                        if (key in stepSchema.properties &&
-                            expr.includes('flow_input.') &&
-                            !expr.includes('flow_input.iter') &&
-                            (!$flowStore.schema || !(snakeKey in $flowStore.schema.properties)) // prevent overriding flow inputs
-                        ) {
-                            copilotFlowInputs[snakeKey] = stepSchema.properties[snakeKey];
-                            if (stepSchema.required.includes(snakeKey)) {
-                                copilotFlowRequiredInputs.push(snakeKey);
+                    Object.entries(allExprs).forEach(([key, expr]) => {
+                        if (expr.includes('flow_input.') && !expr.includes('flow_input.iter.')) {
+                            const flowInputKey = expr.match(/flow_input\.([A-Za-z0-9_]+)/)?.[1];
+                            if (flowInputKey !== undefined &&
+                                (!$flowStore.schema || !(flowInputKey in $flowStore.schema.properties)) // prevent overriding flow inputs
+                            ) {
+                                if (key in stepSchema.properties) {
+                                    copilotFlowInputs[flowInputKey] = stepSchema.properties[key];
+                                    if (stepSchema.required.includes(key)) {
+                                        copilotFlowRequiredInputs.push(flowInputKey);
+                                    }
+                                }
+                                else {
+                                    // when the key is nested (e.g. body.content)
+                                    const [firstKey, ...rest] = key.split('.');
+                                    const restKey = rest.join('.');
+                                    const firstKeyProperties = stepSchema.properties[firstKey]?.properties;
+                                    if (firstKeyProperties !== undefined && restKey in firstKeyProperties) {
+                                        copilotFlowInputs[flowInputKey] = firstKeyProperties[restKey];
+                                        if (firstKeyProperties[restKey].required?.includes(flowInputKey)) {
+                                            copilotFlowRequiredInputs.push(flowInputKey);
+                                        }
+                                    }
+                                }
                             }
                         }
                     });
@@ -606,12 +626,13 @@ async function genFlow(idx, flowModules, stepOnly = false) {
                     Object.entries(inputs).forEach(([key, expr]) => {
                         flowModule.value.input_transforms[key] = {
                             type: 'javascript',
-                            expr: expr.replaceAll(/flow_input\.([A-Za-z0-9_]+)/g, (_, p1) => 'flow_input.' + p1)
+                            expr
                         };
+                        $shouldUpdatePropertyType[key] = 'javascript';
                     });
                 }
                 else {
-                    if (module.source === 'hub' &&
+                    if (isHubStep &&
                         pastModule !== undefined &&
                         !$copilotInfo.exists_openai_resource_path) {
                         sendUserToast('For better input generation, enable Windmill AI in the workspace settings', true);
@@ -650,10 +671,21 @@ async function genFlow(idx, flowModules, stepOnly = false) {
                                         : 'flow_input.' + snakeKey
                                 : 'flow_input.' + snakeKey
                         };
+                        $shouldUpdatePropertyType[key] = 'javascript';
                     }
                 }
                 $flowStore = $flowStore; // force rerendering
             }
+            else {
+                if (pastModule !== undefined &&
+                    pastModule.value.type !== 'rawscript' &&
+                    pastModule.value.type !== 'script') {
+                    sendUserToast(`Linking to previous step ${pastModule.id} of type ${pastModule.value.type} is not yet supported`, true);
+                }
+                else {
+                    sendUserToast('Something went wrong, could not generate step inputs', true);
+                }
+            }
         }
         catch (err) {
             console.error(err);
@@ -697,40 +729,6 @@ async function finishCopilotFlowBuilder() {
     copilotLoading = true;
     select('Input');
     $copilotCurrentStepStore = 'Input';
-    copilotStatus = 'Setting flow inputs...';
-    // filter out unused flow inputs
-    const flowInputs = {};
-    const required = new Set();
-    function getFlowInputs(modules) {
-        for (const module of modules) {
-            if (module.value.type === 'rawscript') {
-                for (const moduleAttr of Object.keys(module.value.input_transforms)) {
-                    const input = module.value.input_transforms[moduleAttr];
-                    if (input.type === 'javascript' &&
-                        input.expr.includes('flow_input.') &&
-                        !input.expr.includes('flow_input.iter')) {
-                        const flowAttr = input.expr.split('.')[1];
-                        const schema = $flowStateStore[module.id].schema;
-                        const schemaProperty = Object.entries(schema.properties).find((x) => x[0] === moduleAttr)?.[1];
-                        if (schemaProperty) {
-                            flowInputs[flowAttr] = schemaProperty;
-                            required.add(flowAttr);
-                        }
-                    }
-                }
-            }
-            else if (module.value.type === 'forloopflow') {
-                getFlowInputs(module.value.modules);
-            }
-        }
-    }
-    getFlowInputs($flowStore.value.modules);
-    $flowStore.schema = {
-        $schema: 'https://json-schema.org/draft/2020-12/schema',
-        properties: flowInputs,
-        required: Array.from(required),
-        type: 'object'
-    };
     copilotStatus = "Done! Just check the flow's inputs and you're good to go!";
     $copilotCurrentStepStore = undefined;
     copilotLoading = false;

package/package/components/FlowBuilderTutorials.svelte

@@ -21,9 +21,7 @@ let flowTutorials = undefined;
 				variant="border"
 				id="tutorials-button"
 				startIcon={{ icon: BookOpen }}
-			>
-				Tutorials
-			</Button>
+			/>
 		</svelte:fragment>
 		<svelte:fragment slot="items">
 			<TutorialItem

package/package/components/FlowLoopIterationPreview.svelte

@@ -0,0 +1,145 @@
+<script>import { Job, JobService } from '../gen';
+import { workspaceStore } from '../stores';
+import { Button, Kbd } from './common';
+import { createEventDispatcher, getContext } from 'svelte';
+import { runFlowPreview } from './flows/utils';
+import SchemaForm from './SchemaForm.svelte';
+import FlowStatusViewer from '../components/FlowStatusViewer.svelte';
+import FlowProgressBar from './flows/FlowProgressBar.svelte';
+import { Play, RefreshCw, X } from 'lucide-svelte';
+import { getModifierKey } from '../utils';
+export let open;
+export let jobId = undefined;
+export let job = undefined;
+export let modules;
+export let previewArgs = {};
+const schema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    properties: {
+        iter: {
+            type: 'object',
+            properties: {
+                index: {
+                    type: 'number'
+                },
+                value: {
+                    type: 'object'
+                }
+            }
+        }
+    },
+    required: [],
+    type: 'object'
+};
+let selectedJobStep = undefined;
+let isRunning = false;
+let jobProgressReset;
+export function test() {
+    runPreview(previewArgs, undefined);
+}
+const { flowStateStore, pathStore } = getContext('FlowEditorContext');
+const dispatch = createEventDispatcher();
+export async function runPreview(args, restartedFrom) {
+    jobProgressReset();
+    const newFlow = { value: { modules }, summary: '' };
+    jobId = await runFlowPreview(args, newFlow, $pathStore, restartedFrom);
+    isRunning = true;
+}
+function onKeyDown(event) {
+    if (open) {
+        switch (event.key) {
+            case 'Enter':
+                if (event.ctrlKey || event.metaKey) {
+                    event.preventDefault();
+                    runPreview(previewArgs, undefined);
+                }
+                break;
+        }
+    }
+}
+$: if (job?.type === 'CompletedJob') {
+    isRunning = false;
+}
+</script>
+
+<svelte:window on:keydown={onKeyDown} />
+
+<div class="flex flex-col space-y-2 h-screen bg-surface px-6 py-2 w-full" id="flow-preview-content">
+	<div class="flex flex-row justify-between w-full items-center gap-x-2">
+		<div class="w-8">
+			<Button
+				on:click={() => dispatch('close')}
+				startIcon={{ icon: X }}
+				iconOnly
+				size="sm"
+				color="light"
+				btnClasses="hover:bg-surface-hover  bg-surface-secondaryw-8 h-8 rounded-full p-0"
+			/>
+		</div>
+
+		{#if isRunning}
+			<Button
+				color="red"
+				on:click={async () => {
+					isRunning = false
+					try {
+						jobId &&
+							(await JobService.cancelQueuedJob({
+								workspace: $workspaceStore ?? '',
+								id: jobId,
+								requestBody: {}
+							}))
+					} catch {}
+				}}
+				size="sm"
+				btnClasses="w-full max-w-lg"
+				loading={true}
+				clickableWhileLoading
+			>
+				Cancel
+			</Button>
+		{:else}
+			<Button
+				variant="contained"
+				startIcon={{ icon: isRunning ? RefreshCw : Play }}
+				color="dark"
+				size="sm"
+				btnClasses="w-full max-w-lg"
+				on:click={() => runPreview(previewArgs, undefined)}
+				id="flow-editor-test-flow-drawer"
+			>
+				Test iteration &nbsp;<Kbd small isModifier>{getModifierKey()}</Kbd>
+				<Kbd small><span class="text-lg font-bold">⏎</span></Kbd>
+			</Button>
+		{/if}
+		<div />
+	</div>
+	<div class="w-full flex flex-col gap-y-1">
+		<FlowProgressBar {job} bind:reset={jobProgressReset} />
+	</div>
+	<div class="overflow-y-auto grow pr-4">
+		<div class="max-h-1/2 overflow-auto border-b">
+			<SchemaForm
+				noVariablePicker
+				compact
+				class="py-4 max-w-3xl"
+				{schema}
+				bind:args={previewArgs}
+			/>
+		</div>
+		<div class="pt-4 grow">
+			{#if jobId}
+				<FlowStatusViewer
+					{flowStateStore}
+					{jobId}
+					on:jobsLoaded={({ detail }) => {
+						job = detail
+					}}
+					bind:selectedJobStep
+				/>
+			{:else}
+				<div class="italic text-tertiary h-full grow"> Flow status will be displayed here </div>
+			{/if}
+		</div>
+	</div>
+</div>

package/package/components/FlowLoopIterationPreview.svelte.d.ts

@@ -0,0 +1,27 @@
+import { SvelteComponent } from "svelte";
+import { Job, type FlowModule, type RestartedFrom } from '../gen';
+declare const __propDef: {
+    props: {
+        open: boolean;
+        jobId?: string | undefined;
+        job?: Job | undefined;
+        modules: FlowModule[];
+        previewArgs?: Record<string, any> | undefined;
+        test?: (() => void) | undefined;
+        runPreview?: ((args: Record<string, any>, restartedFrom: RestartedFrom | undefined) => Promise<void>) | undefined;
+    };
+    events: {
+        close: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type FlowLoopIterationPreviewProps = typeof __propDef.props;
+export type FlowLoopIterationPreviewEvents = typeof __propDef.events;
+export type FlowLoopIterationPreviewSlots = typeof __propDef.slots;
+export default class FlowLoopIterationPreview extends SvelteComponent<FlowLoopIterationPreviewProps, FlowLoopIterationPreviewEvents, FlowLoopIterationPreviewSlots> {
+    get test(): () => void;
+    get runPreview(): (args: Record<string, any>, restartedFrom: RestartedFrom | undefined) => Promise<void>;
+}
+export {};