windmill-components 1.623.2 → 1.655.0

package/package/components/runs/useJobsLoader.svelte.js

@@ -4,6 +4,7 @@ import { sendUserToast } from '../../toast';
 import { tweened } from 'svelte/motion';
 import { subtractDaysFromDateString } from '../../utils';
 import { CancelablePromiseUtils } from '../../cancelable-promise-utils';
+import { allowWildcards as _allowWildcards } from './runsFilter';
 export function computeJobKinds(jobKindsCat) {
     if (jobKindsCat == 'all') {
         return '';
@@ -45,48 +46,62 @@ export function useJobsLoader(args) {
     let resultError = $derived(_args.resultError ?? '');
     let refreshRate = $derived(_args.refreshRate ?? 5000);
     let syncQueuedRunsCount = $derived(_args.syncQueuedRunsCount ?? true);
-    let computeMinAndMax = $derived(_args.computeMinAndMax);
     let lookback = $derived(_args.lookback ?? 0);
-    let onSetMinMaxTs = $derived(_args.onSetMinMaxTs);
-    let onSetPerPage = $derived(_args.onSetPerPage);
+    let timeframe = $derived(_args?.timeframe);
+    let perPage = $derived(_args?.perPage ?? 1000);
     let label = $derived(filters?.label ?? null);
     let worker = $derived(filters?.worker ?? null);
-    let success = $derived(filters?.success ?? null);
+    let success = $derived(filters?.status ?? null);
     let showSkipped = $derived(filters?.show_skipped ?? false);
-    let showSchedules = $derived(filters?.show_schedules ?? true);
+    let showSchedules = $derived(!filters?.job_trigger_kind?.includes('!schedule'));
     let showFutureJobs = $derived(filters?.show_future_jobs ?? true);
     let resultFilter = $derived(filters?.result);
     let jobTriggerKind = $derived(filters?.job_trigger_kind ?? null);
     let schedulePath = $derived(filters?.schedule_path ?? null);
     let jobKindsCat = $derived(filters?.job_kinds ?? null);
     let allWorkspaces = $derived(filters?.all_workspaces ?? false);
-    let allowWildcards = $derived(filters?.allow_wildcards ?? false);
+    let allowWildcards = $derived(_allowWildcards(filters));
     let concurrencyKey = $derived(filters?.concurrency_key);
     let tag = $derived(filters?.tag);
     let user = $derived(filters?.user);
     let folder = $derived(filters?.folder);
     let path = $derived(filters?.path);
     let argFilter = $derived(filters?.arg);
-    let minTs = $derived(filters?.min_ts ?? null);
-    let maxTs = $derived(filters?.max_ts ?? null);
-    let perPage = $derived(filters?.per_page ?? 100);
+    let broadFilter = $derived(filters?._default_ || undefined);
     let queue_count = $state();
     let suspended_count = $state();
     let loading = $state(false);
-    let lastFetchWentToEnd = $state(false);
+    let loadingExtra = $state(false);
+    let lastFetchWentToEnd = $state(true);
+    let batchProgress = $state(null);
     let completedJobs = $state();
     let externalJobs = $state();
     let extendedJobs = $state();
     let jobs = $state();
     let intervalId = $state();
     let sync = true;
+    let paramChangeTimeout;
+    let paramChangePromise;
+    let slowStreamIntervalId;
+    let currentBatchSize = $state(null);
     function onParamChanges() {
         resetJobs();
+        slowStreamIntervalId = setInterval(() => {
+            sendUserToast('Loading is taking a long time...', 'warning', [{ label: 'Stop loading', callback: () => stopBatchLoading() }], undefined, 8000);
+        }, 15000);
         let promise = loadJobsIntern(true);
-        promise = CancelablePromiseUtils.onTimeout(promise, 4000, () => {
-            sendUserToast('Loading jobs is taking longer than expected...', true, perPage > 25 && onSetPerPage
-                ? [{ label: 'Reduce to 25 items per page', callback: () => onSetPerPage(25) }]
-                : []);
+        if (perPage > 25) {
+            promise = CancelablePromiseUtils.onTimeout(promise, 4000, () => {
+                sendUserToast('Loading jobs is taking longer than expected...', 'warning', [
+                    { label: 'Stream by batches of 25', callback: () => restreamWithSmallBatches() }
+                ]);
+            });
+        }
+        promise = CancelablePromiseUtils.finallyDo(promise, () => {
+            if (slowStreamIntervalId) {
+                clearInterval(slowStreamIntervalId);
+                slowStreamIntervalId = undefined;
+            }
         });
         promise = CancelablePromiseUtils.catchErr(promise, (e) => {
             if (e instanceof CancelError) {
@@ -96,54 +111,86 @@ export function useJobsLoader(args) {
         });
         return promise;
     }
-    let loadingFetch = false;
-    async function loadExtraJobs() {
-        if (jobs && jobs.length > 0) {
-            let minQueueTs = undefined;
-            let minCompletedTs = undefined;
-            let cursor = 0;
-            while (jobs && cursor < jobs?.length) {
-                cursor++;
-                const job = jobs[jobs.length - 1 - cursor];
-                if (job.type == 'CompletedJob') {
-                    minCompletedTs = job.completed_at;
-                    break;
-                }
-                else if (job.type == 'QueuedJob' && minQueueTs == undefined) {
-                    minQueueTs = job.created_at;
-                }
+    function restreamWithBatchSize(size) {
+        paramChangePromise?.cancel();
+        resetJobs();
+        slowStreamIntervalId = setInterval(() => {
+            sendUserToast('Loading is taking a long time...', 'warning', [{ label: 'Stop loading', callback: () => stopBatchLoading() }], undefined, 8000);
+        }, 15000);
+        paramChangePromise = loadJobsIntern(false, size);
+        paramChangePromise = CancelablePromiseUtils.finallyDo(paramChangePromise, () => {
+            if (slowStreamIntervalId) {
+                clearInterval(slowStreamIntervalId);
+                slowStreamIntervalId = undefined;
             }
-            const ts = minCompletedTs ?? minQueueTs;
-            if (!ts) {
-                sendUserToast('No jobs to load from');
-                lastFetchWentToEnd = false;
-                return;
+        });
+        paramChangePromise = CancelablePromiseUtils.catchErr(paramChangePromise, (e) => {
+            if (e instanceof CancelError) {
+                return CancelablePromiseUtils.pure(undefined);
             }
-            // const minCreated = lastJob?.created_at
-            const minCreated = new Date(new Date(ts).getTime() - 1).toISOString();
-            let olderJobs = await fetchJobs(minCreated, minTs, undefined);
-            jobs = updateWithNewJobs(olderJobs ?? [], jobs ?? []);
-            computeCompletedJobs();
-            lastFetchWentToEnd = olderJobs?.length < perPage;
+            return CancelablePromiseUtils.err(e);
+        });
+    }
+    function restreamWithSmallBatches() {
+        restreamWithBatchSize(25);
+    }
+    function restreamWithSingleItems() {
+        restreamWithBatchSize(1);
+    }
+    let loadingFetch = false;
+    async function loadExtraJobs() {
+        loading = true;
+        loadingExtra = true;
+        const batchSize = Math.min(perPage, 1000);
+        await loadExtraJobsBatch(batchSize);
+        loadingExtra = false;
+    }
+    function loadExtraJobsBatch(batchSize) {
+        if (!jobs || jobs.length === 0) {
+            lastFetchWentToEnd = true;
+            return CancelablePromiseUtils.pure(undefined);
         }
-        else {
-            lastFetchWentToEnd = false;
+        const lastJob = jobs[jobs.length - 1];
+        const ts = lastJob.created_at;
+        if (!ts) {
+            lastFetchWentToEnd = true;
+            return CancelablePromiseUtils.pure(undefined);
         }
+        const cursorTs = new Date(new Date(ts).getTime() - 1).toISOString();
+        const minTs = timeframe?.computeMinMax().minTs ?? null;
+        return CancelablePromiseUtils.map(fetchJobs(null, minTs, undefined, cursorTs, batchSize), (olderJobs) => {
+            jobs = updateWithNewJobs(olderJobs ?? [], jobs ?? []);
+            if (extendedJobs) {
+                extendedJobs.jobs = jobs ?? [];
+                extendedJobs = extendedJobs;
+            }
+            computeCompletedJobs();
+            lastFetchWentToEnd = (olderJobs?.length ?? 0) < batchSize;
+            loading = false;
+        });
     }
-    function fetchJobs(completedBefore, completedAfter, createdAfterQueue) {
+    function fetchJobs(completedBefore, completedAfter, createdAfterQueue, createdBefore, perPageOverride) {
         if (_args.skip)
             return CancelablePromiseUtils.pure([]);
         loadingFetch = true;
-        let scriptPathStart = folder === null || folder === '' ? undefined : `f/${folder}/`;
-        let scriptPathExact = path === null || path === '' ? undefined : path;
+        let scriptPathStart = folder == null || folder === '' ? undefined : `f/${folder}/`;
+        let scriptPathExact = path == null || path === '' ? undefined : path;
+        let isQueueOnly = success == 'running' || success == 'suspended' || success == 'waiting';
+        let isCompletedOnly = success == 'success' || success == 'failure';
         let promise = JobService.listJobs({
             workspace: currentWorkspace,
-            completedBefore: completedBefore ?? undefined,
-            completedAfter: completedAfter ?? undefined,
-            createdAfterQueue,
+            createdBefore: createdBefore ?? undefined,
+            completedBefore: isQueueOnly ? undefined : (completedBefore ?? undefined),
+            completedAfter: isQueueOnly ? undefined : (completedAfter ?? undefined),
+            createdBeforeQueue: isQueueOnly ? (completedBefore ?? undefined) : undefined,
+            createdAfterQueue: isCompletedOnly
+                ? undefined
+                : isQueueOnly
+                    ? (completedAfter ?? createdAfterQueue)
+                    : createdAfterQueue,
             schedulePath: schedulePath ?? undefined,
             scriptPathExact,
-            createdBy: user === null || user === '' ? undefined : user,
+            createdBy: user == null || user === '' ? undefined : user,
             scriptPathStart: scriptPathStart,
             jobKinds: jobKindsCat == 'all' || jobKinds == '' ? undefined : jobKinds,
             success: success == 'success' ? true : success == 'failure' ? false : undefined,
@@ -155,9 +202,9 @@ export function useJobsLoader(args) {
             isSkipped: showSkipped ? undefined : false,
             // isFlowStep: jobKindsCat != 'all' ? false : undefined,
             hasNullParent: jobKindsCat != 'all' ? true : undefined,
-            label: label === null || label === '' ? undefined : label,
-            tag: tag === null || tag === '' ? undefined : tag,
-            worker: worker === null || worker === '' ? undefined : worker,
+            label: label == null || label === '' ? undefined : label,
+            tag: tag == null || tag === '' ? undefined : tag,
+            worker: worker == null || worker === '' ? undefined : worker,
             isNotSchedule: showSchedules == false ? true : undefined,
             suspended: success == 'waiting' ? false : success == 'suspended' ? true : undefined,
             scheduledForBeforeNow: showFutureJobs == false || success == 'waiting' || success == 'suspended'
@@ -169,8 +216,9 @@ export function useJobsLoader(args) {
                 : undefined,
             triggerKind: jobTriggerKind ?? undefined,
             allWorkspaces: allWorkspaces ? true : undefined,
-            perPage,
-            allowWildcards: allowWildcards ? true : undefined
+            perPage: perPageOverride ?? perPage,
+            allowWildcards: allowWildcards ? true : undefined,
+            broadFilter
         });
         promise = CancelablePromiseUtils.catchErr(promise, (e) => {
             if (e instanceof CancelError)
@@ -198,16 +246,16 @@ export function useJobsLoader(args) {
             // createdOrStartedAfter: startedAfter,
             // createdOrStartedAfterCompletedJobs: startedAfterCompletedJobs,
             schedulePath: schedulePath ?? undefined,
-            scriptPathExact: path === null || path === '' ? undefined : path,
-            createdBy: user === null || user === '' ? undefined : user,
-            scriptPathStart: folder === null || folder === '' ? undefined : `f/${folder}/`,
+            scriptPathExact: path == null || path === '' ? undefined : path,
+            createdBy: user == null || user === '' ? undefined : user,
+            scriptPathStart: folder == null || folder === '' ? undefined : `f/${folder}/`,
             jobKinds: jobKindsCat == 'all' || jobKinds == '' ? undefined : jobKinds,
             success: success == 'success' ? true : success == 'failure' ? false : undefined,
             running: success == 'running' ? true : undefined,
             isSkipped: showSkipped ? undefined : false,
             isFlowStep: jobKindsCat != 'all' ? false : undefined,
-            label: label === null || label === '' ? undefined : label,
-            tag: tag === null || tag === '' ? undefined : tag,
+            label: label == null || label === '' ? undefined : label,
+            tag: tag == null || tag === '' ? undefined : tag,
             isNotSchedule: showSchedules == false ? true : undefined,
             scheduledForBeforeNow: showFutureJobs == false ? true : undefined,
             args: argFilter && argFilter != '{}' && argFilter != '' && argError == '' ? argFilter : undefined,
@@ -234,16 +282,33 @@ export function useJobsLoader(args) {
             resetJobs();
         await loadJobsIntern(shouldGetCount);
     }
+    function stopBatchLoading() {
+        paramChangePromise?.cancel();
+        if (slowStreamIntervalId) {
+            clearInterval(slowStreamIntervalId);
+            slowStreamIntervalId = undefined;
+        }
+        batchProgress = null;
+        currentBatchSize = null;
+        loading = false;
+    }
     function resetJobs() {
         jobs = undefined;
         completedJobs = undefined;
         externalJobs = undefined;
         extendedJobs = undefined;
         lastFetchWentToEnd = false;
+        batchProgress = null;
+        currentBatchSize = null;
+        if (slowStreamIntervalId) {
+            clearInterval(slowStreamIntervalId);
+            slowStreamIntervalId = undefined;
+        }
         intervalId && clearInterval(intervalId);
         intervalId = setInterval(syncer, refreshRate);
     }
-    function loadJobsIntern(shouldGetCount) {
+    function loadJobsIntern(shouldGetCount, overrideBatchSize) {
+        const { minTs, maxTs } = timeframe?.computeMinMax() ?? { minTs: null, maxTs: null };
         if (shouldGetCount) {
             getCount();
         }
@@ -253,15 +318,62 @@ export function useJobsLoader(args) {
         // lookback won't be needed anymore (just filter ended_at > minTs instead
         const extendedMinTs = subtractDaysFromDateString(minTs, lookback);
         if (concurrencyKey == null || concurrencyKey === '') {
-            return CancelablePromiseUtils.map(fetchJobs(maxTs, null, extendedMinTs), (newJobs) => {
+            const batchSize = overrideBatchSize ?? Math.min(perPage, 1000);
+            const isBatched = perPage > batchSize;
+            if (isBatched) {
+                batchProgress = { loaded: 0, total: perPage };
+            }
+            currentBatchSize = batchSize;
+            let slowBatchToastShown = false;
+            let firstFetchPromise = fetchJobs(maxTs, extendedMinTs ?? null, extendedMinTs, undefined, batchSize);
+            if (isBatched && batchSize > 1) {
+                firstFetchPromise = CancelablePromiseUtils.onTimeout(firstFetchPromise, 4000, () => {
+                    if (!slowBatchToastShown) {
+                        slowBatchToastShown = true;
+                        sendUserToast(`Streaming by batches of ${batchSize} is slow, try loading one at a time`, 'warning', [{ label: 'Stream 1 by 1', callback: () => restreamWithSingleItems() }]);
+                    }
+                });
+            }
+            let p = CancelablePromiseUtils.map(firstFetchPromise, (newJobs) => {
                 extendedJobs = { jobs: newJobs, obscured_jobs: [] };
                 // Filter on minTs here and not in the backend
                 // to get enough data for the concurrency graph
                 jobs = sortMinDate(minTs, newJobs);
                 externalJobs = [];
                 computeCompletedJobs();
+                lastFetchWentToEnd = newJobs.length < batchSize;
                 loading = false;
+                if (isBatched) {
+                    batchProgress = { loaded: jobs?.length ?? 0, total: perPage };
+                }
+            });
+            if (isBatched) {
+                const numExtraBatches = Math.ceil(perPage / batchSize) - 1;
+                for (let i = 0; i < numExtraBatches; i++) {
+                    p = CancelablePromiseUtils.then(p, () => {
+                        if (lastFetchWentToEnd || !jobs)
+                            return CancelablePromiseUtils.pure(undefined);
+                        loading = true;
+                        let batchPromise = CancelablePromiseUtils.pipe(loadExtraJobsBatch(batchSize), () => {
+                            batchProgress = { loaded: jobs?.length ?? 0, total: perPage };
+                        });
+                        if (batchSize > 1 && !slowBatchToastShown) {
+                            batchPromise = CancelablePromiseUtils.onTimeout(batchPromise, 4000, () => {
+                                if (!slowBatchToastShown) {
+                                    slowBatchToastShown = true;
+                                    sendUserToast(`Streaming by batches of ${batchSize} is slow, try loading one at a time`, 'warning', [{ label: 'Stream 1 by 1', callback: () => restreamWithSingleItems() }]);
+                                }
+                            });
+                        }
+                        return batchPromise;
+                    });
+                }
+            }
+            p = CancelablePromiseUtils.pipe(p, () => {
+                batchProgress = null;
+                currentBatchSize = null;
             });
+            return p;
         }
         else {
             return CancelablePromiseUtils.map(fetchExtendedJobs(concurrencyKey, maxTs, extendedMinTs ?? null), (newExtendedJobs) => {
@@ -284,6 +396,7 @@ export function useJobsLoader(args) {
                     externalJobs = computeExternalJobs(newExternalJobs);
                 }
                 computeCompletedJobs();
+                lastFetchWentToEnd = newJobs.length < perPage;
                 loading = false;
             });
         }
@@ -310,24 +423,18 @@ export function useJobsLoader(args) {
     }
     let lastQueueTs = undefined;
     async function syncer() {
-        if (success == 'waiting') {
-            onSetMinMaxTs?.(null, null);
-        }
         if (loadingFetch) {
             return;
         }
+        if (timeframe?.type === 'manual') {
+            return;
+        }
         if (sync) {
             if (syncQueuedRunsCount) {
                 getCount();
             }
-            const ts = computeMinAndMax?.();
-            if (ts) {
-                onSetMinMaxTs?.(ts.minTs, ts.maxTs);
-                if (maxTs != undefined) {
-                    loadJobsIntern(false);
-                }
-            }
-            if (jobs && maxTs == undefined) {
+            const { minTs, maxTs } = timeframe?.computeMinMax() ?? { minTs: null, maxTs: null };
+            if (jobs) {
                 if (success == 'running') {
                     loadJobsIntern(false);
                 }
@@ -452,11 +559,32 @@ export function useJobsLoader(args) {
         if (intervalId) {
             clearInterval(intervalId);
         }
+        if (slowStreamIntervalId) {
+            clearInterval(slowStreamIntervalId);
+            slowStreamIntervalId = undefined;
+        }
+        paramChangePromise?.cancel();
     });
     $effect(() => {
         Object.keys(filters ?? {}).map((k) => filters?.[k]);
-        let p = untrack(() => onParamChanges());
-        return () => p.cancel();
+        currentWorkspace;
+        lookback;
+        perPage;
+        showSchedules;
+        showFutureJobs;
+        clearTimeout(paramChangeTimeout);
+        paramChangePromise?.cancel();
+        paramChangeTimeout = setTimeout(() => {
+            paramChangePromise = untrack(() => onParamChanges());
+        }, 0);
+        return () => {
+            clearTimeout(paramChangeTimeout);
+            paramChangePromise?.cancel();
+            if (slowStreamIntervalId) {
+                clearInterval(slowStreamIntervalId);
+                slowStreamIntervalId = undefined;
+            }
+        };
     });
     $effect(() => {
         ;
@@ -479,6 +607,14 @@ export function useJobsLoader(args) {
     return {
         loadExtraJobs,
         loadJobs,
+        stopBatchLoading,
+        restreamWithBatchSize,
+        get batchProgress() {
+            return batchProgress;
+        },
+        get currentBatchSize() {
+            return currentBatchSize;
+        },
         get queue_count() {
             return queue_count;
         },
@@ -488,6 +624,9 @@ export function useJobsLoader(args) {
         get loading() {
             return loading;
         },
+        get loadingExtra() {
+            return loadingExtra;
+        },
         get completedJobs() {
             return completedJobs;
         },

package/package/components/schedules/schedulesFilter.d.ts

@@ -0,0 +1,69 @@
+import { FileCode, FileText, Clock, Braces, Users } from 'lucide-svelte';
+export declare function buildSchedulesFilterSchema({ paths, scriptPaths, showUserFoldersFilter, userFoldersLabel }: {
+    paths: string[];
+    scriptPaths: string[];
+    showUserFoldersFilter?: boolean;
+    userFoldersLabel?: string;
+}): {
+    user_folders_only?: {
+        type: "boolean";
+        label: string;
+        icon: typeof Users;
+        description: string;
+    } | undefined;
+    _default_: {
+        type: "string";
+        hidden: true;
+    };
+    schedule_path: {
+        type: "oneof";
+        options: {
+            label: string;
+            value: string;
+        }[];
+        allowCustomValue: true;
+        allowNegative: false;
+        allowMultiple: false;
+        label: string;
+        icon: typeof Clock;
+        description: string;
+    };
+    path_start: {
+        type: "string";
+        label: string;
+        icon: typeof FileCode;
+        description: string;
+    };
+    path: {
+        type: "oneof";
+        options: {
+            label: string;
+            value: string;
+        }[];
+        allowCustomValue: true;
+        allowNegative: false;
+        allowMultiple: false;
+        label: string;
+        icon: typeof FileCode;
+        description: string;
+    };
+    description: {
+        type: "string";
+        label: string;
+        icon: typeof FileText;
+        description: string;
+    };
+    summary: {
+        type: "string";
+        label: string;
+        icon: typeof FileText;
+        description: string;
+    };
+    args: {
+        type: "string";
+        format: "json";
+        label: string;
+        icon: typeof Braces;
+        description: string;
+    };
+};

package/package/components/schedules/schedulesFilter.js

@@ -0,0 +1,64 @@
+import { FileCode, FileText, Clock, Braces, Users } from 'lucide-svelte';
+export function buildSchedulesFilterSchema({ paths, scriptPaths, showUserFoldersFilter, userFoldersLabel }) {
+    return {
+        _default_: {
+            type: 'string',
+            hidden: true
+        },
+        schedule_path: {
+            type: 'oneof',
+            options: paths.map((s) => ({ label: s, value: s })),
+            allowCustomValue: true,
+            allowNegative: false,
+            allowMultiple: false,
+            label: 'Schedule path',
+            icon: Clock,
+            description: 'Filter by exact schedule path'
+        },
+        path_start: {
+            type: 'string',
+            label: 'Path prefix',
+            icon: FileCode,
+            description: 'Filter by schedule path prefix'
+        },
+        path: {
+            type: 'oneof',
+            options: scriptPaths.map((s) => ({ label: s, value: s })),
+            allowCustomValue: true,
+            allowNegative: false,
+            allowMultiple: false,
+            label: 'Script/Flow path',
+            icon: FileCode,
+            description: 'Filter by the script or flow path that the schedule runs'
+        },
+        description: {
+            type: 'string',
+            label: 'Description',
+            icon: FileText,
+            description: 'Search in schedule description'
+        },
+        summary: {
+            type: 'string',
+            label: 'Summary',
+            icon: FileText,
+            description: 'Search in schedule summary'
+        },
+        args: {
+            type: 'string',
+            format: 'json',
+            label: 'Args subset',
+            icon: Braces,
+            description: 'Filter by JSON args subset match (e.g., {"param": "value"})'
+        },
+        ...(showUserFoldersFilter
+            ? {
+                user_folders_only: {
+                    type: 'boolean',
+                    label: userFoldersLabel || 'User folders only',
+                    icon: Users,
+                    description: 'Show only schedules in user folders'
+                }
+            }
+            : {})
+    };
+}

package/package/components/schema/AddProperty.svelte

@@ -3,7 +3,7 @@ import { emptySchema, sendUserToast } from '../../utils';
 import { createEventDispatcher } from 'svelte';
 import SimpleEditor from '../SimpleEditor.svelte';
 import AddPropertyForm from './AddPropertyForm.svelte';
-export let schema = emptySchema();
+let { schema = $bindable(emptySchema()) } = $props();
 export const DEFAULT_PROPERTY = {
     selectedType: 'string',
     description: '',

package/package/components/schema/AddProperty.svelte.d.ts

@@ -1,4 +1,7 @@
 import { type Schema, type ModalSchemaProperty } from '../../common';
+interface Props {
+    schema?: Schema | any;
+}
 interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
     new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
         $$bindings?: Bindings;
@@ -12,17 +15,13 @@ interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> =
     };
     z_$$bindings?: Bindings;
 }
-declare const AddProperty: $$__sveltets_2_IsomorphicComponent<{
-    schema?: Schema | any;
-    DEFAULT_PROPERTY?: ModalSchemaProperty;
-    handleDeleteArgument?: (argPath: string[], nschema?: Schema) => void;
-}, {
+declare const AddProperty: $$__sveltets_2_IsomorphicComponent<Props, {
     change: CustomEvent<any>;
 } & {
     [evt: string]: CustomEvent<any>;
 }, {}, {
     DEFAULT_PROPERTY: ModalSchemaProperty;
     handleDeleteArgument: (argPath: string[], nschema?: Schema) => void;
-}, string>;
+}, "schema">;
 type AddProperty = InstanceType<typeof AddProperty>;
 export default AddProperty;

package/package/components/schema/AddPropertyForm.svelte

@@ -2,7 +2,7 @@
 import { Button } from '../common';
 import { Plus } from 'lucide-svelte';
 import TextInput from '../text_input/TextInput.svelte';
-let name = '';
+let name = $state('');
 const dispatch = createEventDispatcher();
 function addField() {
     dispatch('add', { name });

package/package/components/schema/AddPropertyForm.svelte.d.ts

@@ -15,6 +15,6 @@ declare const AddPropertyForm: $$__sveltets_2_IsomorphicComponent<Record<string,
     add: CustomEvent<any>;
 } & {
     [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
+}, {}, {}, "">;
 type AddPropertyForm = InstanceType<typeof AddPropertyForm>;
 export default AddPropertyForm;

package/package/components/schema/EditableSchemaSdkWrapper.svelte

@@ -1,8 +1,9 @@
-<script lang="ts">import { readFieldsRecursively } from '../../utils';
+<script lang="ts">import { untrack } from 'svelte';
+import { readFieldsRecursively } from '../../utils';
 import { deepEqual } from 'fast-equals';
 import EditableSchemaWrapper from './EditableSchemaWrapper.svelte';
 let { schema: oldSchema, onSchemaChange, ...props } = $props();
-let schema = $state(oldSchema);
+let schema = $state(untrack(() => oldSchema));
 let lastSchema = $state(undefined);
 $effect(() => {
     if (onSchemaChange && schema) {