@svadmin/core 0.23.1 → 0.23.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "author": "zuohuadong",
   "repository": {
     "type": "git",
@@ -9,7 +9,16 @@
   },
   "main": "src/index.ts",
   "devDependencies": {
-    "@types/bun": "^1.3.11"
+    "@happy-dom/global-registrator": "^20.8.9",
+    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/svelte": "^5.3.1",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/bun": "^1.3.11",
+    "@types/jsdom": "^28.0.1",
+    "happy-dom": "^20.8.9",
+    "jsdom": "^29.0.2",
+    "vitest": "^4.1.4"
   },
   "peerDependencies": {
     "svelte": "^5.0.0",
@@ -61,5 +70,13 @@
   "sideEffects": false,
   "type": "module",
   "types": "src/index.ts",
-  "dependencies": {}
+  "dependencies": {},
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": true
+    },
+    "@tanstack/svelte-query": {
+      "optional": true
+    }
+  }
 }

package/src/adapters/casbin.ts

@@ -18,7 +18,7 @@
  * ```
  */
 
-import type { AccessControlProvider, CanParams, CanResult } from '../permissions';
+import type { AccessControlProvider, CanParams, CanResult } from '../permissions.svelte';
 
 /** Casbin Enforcer interface (minimal, to avoid hard dependency on casbin) */
 interface CasbinEnforcer {

package/src/adapters/casl.ts

@@ -19,7 +19,7 @@
  * ```
  */
 
-import type { AccessControlProvider, CanParams, CanResult } from '../permissions';
+import type { AccessControlProvider, CanParams, CanResult } from '../permissions.svelte';
 
 /** CASL Ability interface (minimal, to avoid hard dependency on @casl/ability) */
 interface CaslAbility {

package/src/audit.ts

@@ -53,19 +53,20 @@ export function resetAuditLogProvider(): void {
 export function audit(entry: Omit<AuditEntry, 'timestamp'>): void {
   const fullEntry: AuditEntry = { ...entry, timestamp: new Date().toISOString() };
   try {
-    handler(fullEntry);
-
-    // Also log via provider if set
-    if (auditLogProvider) {
-      auditLogProvider.create({
-        resource: entry.resource ?? '',
-        action: entry.action,
-        data: entry.data ?? entry.details,
-        previousData: entry.previousData,
-        meta: entry.meta,
-      }).catch(e => console.error('[audit] provider create error:', e));
+    const result = handler(fullEntry);
+    if (result && typeof result === 'object' && 'then' in result) {
+      (result as Promise<void>).catch(e => console.error('[audit] handler error:', e));
     }
   } catch (e) {
     console.error('[audit] handler error:', e);
   }
+  if (auditLogProvider) {
+    auditLogProvider.create({
+      resource: entry.resource ?? '',
+      action: entry.action,
+      data: entry.data ?? entry.details,
+      previousData: entry.previousData,
+      meta: entry.meta,
+    }).catch(e => console.error('[audit] provider create error:', e));
+  }
 }

package/src/auth-hooks.svelte.ts

@@ -7,6 +7,11 @@ import { navigate } from './router';
 import { notify } from './notification.svelte';
 import { t } from './i18n.svelte';
 import type { AuthActionResult, CheckResult, Identity, AuthProvider } from './types';
+import { useQueryClient } from '@tanstack/svelte-query';
+
+let _logoutVersion = $state(0);
+export function getLogoutVersion() { return _logoutVersion; }
+export function resetLogoutVersion() { _logoutVersion = 0; }
 
 // ─── Mutate Factory ─────────────────────────────────────────────
 
@@ -59,7 +64,7 @@ export function useLogin(opts?: { errorMessage?: string | false }) {
     method: 'login',
     successMessage: t('common.operationSuccess'),
     errorMessage: opts?.errorMessage ?? t('common.loginFailed'),
-    onSuccess: (result) => { if (result.redirectTo) navigate(result.redirectTo); }
+    onSuccess: (result) => { navigate(result.redirectTo ?? '/'); }
   });
 }
 
@@ -69,7 +74,14 @@ export function useLogout() {
   return createAuthMutation({
     method: 'logout',
     successMessage: null,
-    onSuccess: (result) => { navigate(result.redirectTo ?? '/login'); }
+    onSuccess: (result) => {
+      _logoutVersion++;
+      try {
+        const queryClient = useQueryClient();
+        queryClient.clear();
+      } catch {}
+      navigate(result.redirectTo ?? '/login');
+    }
   });
 }
 
@@ -125,6 +137,10 @@ export function useGetIdentity() {
 
   if (typeof window !== 'undefined') {
     fetch();
+    $effect(() => {
+      void _logoutVersion;
+      data = null;
+    });
   }
 
   return {
@@ -170,6 +186,13 @@ export function useIsAuthenticated() {
   // Initial check
   check();
 
+  if (typeof window !== 'undefined') {
+    $effect(() => {
+      void _logoutVersion;
+      isAuthenticated = false;
+    });
+  }
+
   return {
     get isAuthenticated() { return isAuthenticated; },
     get isLoading() { return isLoading; },

package/src/chatProvider.svelte.ts

@@ -148,13 +148,12 @@ export interface AgentOptions {
  * ```
  */
 export interface AgentProvider {
-  /** Available tools the agent can invoke */
   tools?: AdminTool[];
-  /** Send messages and receive a stream of typed agent events */
   chat(
     messages: ChatMessage[],
     options?: AgentOptions,
   ): AsyncGenerator<AgentEvent, void, unknown>;
+  approveToolCall?(id: string, approved: boolean): void;
 }
 
 // ─── Chat Provider singleton ───────────────────────────────────
@@ -190,14 +189,22 @@ interface ApprovalEntry { id: string; callback: ApprovalCallback }
 let pendingApprovals = $state<ApprovalEntry[]>([]);
 
 export function registerApproval(id: string, callback: ApprovalCallback): void {
+  if (pendingApprovals.some(e => e.id === id)) return;
   pendingApprovals = [...pendingApprovals, { id, callback }];
 }
 
 export function resolveApproval(id: string, approved: boolean): boolean {
   const entry = pendingApprovals.find(e => e.id === id);
   if (!entry) return false;
-  entry.callback(approved);
   pendingApprovals = pendingApprovals.filter(e => e.id !== id);
+  try {
+    const result: unknown = entry.callback(approved);
+    if (result && typeof result === 'object' && 'then' in result) {
+      (result as Promise<unknown>).catch((err) => console.error('[svadmin] Approval callback error:', err));
+    }
+  } catch (err) {
+    console.error('[svadmin] Approval callback error:', err);
+  }
   return true;
 }
 
@@ -216,3 +223,13 @@ export function setChatContext(ctx: ChatContext): void {
 export function getChatContext(): ChatContext {
   return chatContext;
 }
+
+export function resetChatProvider(): void {
+  chatProvider = null;
+  agentProvider = null;
+  for (const entry of pendingApprovals) {
+    try { entry.callback(false); } catch { /* noop */ }
+  }
+  pendingApprovals = [];
+  chatContext = {};
+}

package/src/context.svelte.ts

@@ -5,9 +5,17 @@ import type { DataProvider, AuthProvider, ResourceDefinition } from './types';
 import type { RouterProvider } from './router-provider';
 import { resetNotificationProvider } from './notification.svelte';
 import { resetAuditLogProvider } from './audit';
-import { resetAccessControlProvider } from './permissions';
+import { resetAccessControlProvider } from './permissions.svelte';
 import { resetAdminOptions } from './options.svelte';
 import { resetI18n } from './i18n.svelte';
+import { resetChatProvider } from './chatProvider.svelte';
+import { resetToast } from './toast.svelte';
+import { resetTheme } from './theme.svelte';
+import { resetRouter } from './router';
+import { resetUnsavedChanges } from './unsaved-changes.svelte';
+import { resetGlobalPath } from './useParsed.svelte';
+import { resetLogoutVersion } from './auth-hooks.svelte';
+import { resetSidebarCollapsed } from './hooks.svelte';
 
 // ─── DataProvider (supports single or multiple) ─────────────────
 
@@ -141,4 +149,12 @@ export function resetContext(): void {
   resetAccessControlProvider();
   resetAdminOptions();
   resetI18n();
+  resetChatProvider();
+  resetToast();
+  resetTheme();
+  resetRouter();
+  resetUnsavedChanges();
+  resetGlobalPath();
+  resetLogoutVersion();
+  resetSidebarCollapsed();
 }

package/src/data-transfer.svelte.ts

@@ -25,10 +25,11 @@ export function useExport<TData extends BaseRecord = BaseRecord>(options: UseExp
   let isLoading = $state(false);
 
   async function triggerExport() {
-    const provider = getDataProviderForResource(resource, options.dataProviderName);
+    const exportResource = resource;
     isLoading = true;
 
     try {
+      const provider = getDataProviderForResource(exportResource, options.dataProviderName);
       const batchSize = options.pageSize ?? 20;
       const maxItems = options.maxItemCount ?? Infinity;
       let allRecords: TData[] = [];
@@ -36,7 +37,7 @@ export function useExport<TData extends BaseRecord = BaseRecord>(options: UseExp
 
       while (allRecords.length < maxItems) {
         const result = await provider.getList<TData>({
-          resource,
+          resource: exportResource,
           pagination: { current: page, pageSize: batchSize },
           sorters: options.sorters,
           filters: options.filters,
@@ -57,7 +58,11 @@ export function useExport<TData extends BaseRecord = BaseRecord>(options: UseExp
 
       if (options.download !== false && typeof document !== 'undefined') {
         const fields = Object.keys(mapped[0]);
-        const escapeCsvField = (s: string) => s.includes(',') || s.includes('"') || s.includes('\n') || s.includes('\r') ? `"${s.replace(/"/g, '""')}"` : s;
+        const escapeCsvField = (s: string) => {
+          let val = s;
+          if (/^[=+@\t\r]/.test(val)) val = "'" + val;
+          return val.includes(',') || val.includes('"') || val.includes('\n') || val.includes('\r') ? `"${val.replace(/"/g, '""')}"` : val;
+        };
         const header = fields.map(escapeCsvField).join(',');
         const rows = mapped.map(record =>
           fields.map(f => {
@@ -72,9 +77,9 @@ export function useExport<TData extends BaseRecord = BaseRecord>(options: UseExp
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a');
         a.href = url;
-        a.download = `${resource}_export.csv`;
+        a.download = `${exportResource}_export.csv`;
         a.click();
-        URL.revokeObjectURL(url);
+        setTimeout(() => URL.revokeObjectURL(url), 10000);
       }
 
       return allRecords;
@@ -113,12 +118,13 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
   let mutationResult = $state<{ succeeded: unknown[]; errored: { request: unknown; error: unknown }[] } | null>(null);
 
   async function handleChange(info: { file: File }) {
-    const provider = getDataProviderForResource(resource, options.dataProviderName);
+    const importResource = resource;
     isLoading = true;
     const succeeded: unknown[] = [];
     const errored: { request: unknown; error: unknown }[] = [];
 
     try {
+      const provider = getDataProviderForResource(importResource, options.dataProviderName);
       let text = await info.file.text();
       // Strip BOM
       if (text.charCodeAt(0) === 0xFEFF) {
@@ -126,7 +132,11 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
       }
 
       const rows = parseCSV(text);
-      if (rows.length < 2) return;
+      if (rows.length < 2) {
+        mutationResult = { succeeded: [], errored: [] };
+        options.onFinish?.({ succeeded: [], errored: [] });
+        return;
+      }
 
       const headers = rows[0];
       const records: Record<string, unknown>[] = [];
@@ -144,7 +154,7 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
       if (batchSize === 1) {
         for (const record of records) {
           try {
-            const res = await provider.create({ resource, variables: record, meta: options.meta });
+            const res = await provider.create({ resource: importResource, variables: record, meta: options.meta });
             succeeded.push(res);
           } catch (error) {
             errored.push({ request: record, error });
@@ -157,16 +167,15 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
           const batch = records.slice(i, i + batchSize);
           if (provider.createMany) {
             try {
-              const res = await provider.createMany({ resource, variables: batch, meta: options.meta });
+              const res = await provider.createMany({ resource: importResource, variables: batch, meta: options.meta });
               succeeded.push(res);
             } catch (error) {
               errored.push({ request: batch, error });
             }
           } else {
-            // Fallback: loop internal items inside batch securely instead of breaking whole batch
             for (const record of batch) {
               try {
-                const res = await provider.create({ resource, variables: record, meta: options.meta });
+                const res = await provider.create({ resource: importResource, variables: record, meta: options.meta });
                 succeeded.push(res);
               } catch (error) {
                 errored.push({ request: record, error });
@@ -180,6 +189,9 @@ export function useImport<TData = Record<string, unknown>>(options: UseImportOpt
 
       mutationResult = { succeeded, errored };
       options.onFinish?.({ succeeded, errored });
+    } catch (error) {
+      mutationResult = { succeeded, errored: [...errored, { request: null, error }] };
+      options.onFinish?.({ succeeded, errored: mutationResult.errored });
     } finally {
       isLoading = false;
     }

package/src/form-hooks.svelte.ts

@@ -246,7 +246,7 @@ export function useForm<
     values = { ...initialValues } as TVariables;
     tainted = {};
     clearErrors();
-    queryInitializedId = undefined;
+    queryInitializedId = currentId;
   }
 
   // ─── Server error handling ──────────────────────────────────────
@@ -313,17 +313,25 @@ export function useForm<
 
   const createMut = createMutation(() => ({
     ...options.createMutationOptions,
-    mutationFn: (variables: TVariables) => provider.create<TData, TVariables>({ resource, variables, meta: mutationMeta }),
-    onSuccess: (data: { data: TData }) => {
-      invalidateByScopes(queryClient, resource, invalidateScopes, ['list', 'many']);
+    mutationFn: (variables: unknown) => {
+      const targetResource = resource;
+      const targetMeta = mutationMeta;
+      return provider.create<TData, TVariables>({ resource: targetResource, variables: variables as TVariables, meta: targetMeta });
+    },
+    onMutate: async () => {
+      return { targetResource: resource };
+    },
+    onSuccess: (data: { data: TData }, _vars: unknown, context: unknown) => {
+      const ctx = context as { targetResource?: string } | undefined;
+      const res = ctx?.targetResource ?? resource;
+      invalidateByScopes(queryClient, res, invalidateScopes, ['list', 'many'], undefined, options.dataProviderName);
       if (successNotification !== false) notify({ type: 'success', message: typeof successNotification === 'string' ? successNotification : t('common.createSuccess') });
-      const pk = getResource(resource).primaryKey ?? 'id';
+      const pk = getResource(res).primaryKey ?? 'id';
       const newId = (data.data as Record<string, unknown>)[pk];
-      audit({ action: 'create', resource, recordId: String(newId) });
-      // Publish live event
+      audit({ action: 'create', resource: res, recordId: String(newId) });
       try {
         const lp = getLiveProvider();
-        if (lp?.publish) lp.publish({ type: 'INSERT', resource, payload: { ids: newId != null ? [newId as string | number] : [] } });
+        if (lp?.publish) lp.publish({ type: 'INSERT', resource: res, payload: { ids: newId != null ? [newId as string | number] : [] } });
       } catch { /* no live provider */ }
       onMutationSuccess?.(data);
       if (redirectOverride !== false) {
@@ -337,6 +345,9 @@ export function useForm<
   const updateMut = createMutation<{ data: TData }, unknown, TVariables>(() => ({
     ...options.updateMutationOptions,
     mutationFn: async (variables: TVariables) => {
+      const targetId = currentId!;
+      const targetResource = resource;
+      const targetMeta = mutationMeta;
       if (mutationMode === 'undoable') {
         await new Promise<void>((resolve, reject) => {
           toast.undoable(t('common.actionCanBeUndone'), undoableTimeout, () => {
@@ -344,38 +355,48 @@ export function useForm<
           }, resolve);
         });
       }
-      return provider.update<TData, TVariables>({ resource, id: currentId!, variables, meta: mutationMeta });
+      return provider.update<TData, TVariables>({ resource: targetResource, id: targetId, variables, meta: targetMeta });
     },
     onMutate: async (variables: TVariables) => {
-      if (mutationMode === 'pessimistic') return;
-      await queryClient.cancelQueries({ predicate: (q) => q.queryKey[1] === resource });
-      const previousQueries = queryClient.getQueriesData({ predicate: (q) => q.queryKey[1] === resource });
+      if (mutationMode === 'pessimistic') return { targetId: currentId, targetResource: resource };
+      const targetId = currentId;
+      const targetResource = resource;
+      const dpN = options.dataProviderName;
+      const dp = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
+      await queryClient.cancelQueries({ predicate: (q) => dp(q) && q.queryKey[1] === resource });
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resource });
       if (optimisticUpdateMap?.list !== false) {
-        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'list' }, (old: unknown) => {
+        queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resource && q.queryKey[2] === 'list' }, (old: unknown) => {
           if (!old || typeof old !== 'object' || !('data' in old)) return old;
           const o = old as { data: Record<string, unknown>[] };
           const pk = getResource(resource).primaryKey ?? 'id';
-          return { ...o, data: o.data.map((item) => String(item[pk]) === String(currentId) ? deepMerge(item, variables) : item) };
+          return { ...o, data: o.data.map((item) => String(item[pk]) === String(targetId) ? deepMerge(item, variables) : item) };
         });
       }
-      if (optimisticUpdateMap?.detail !== false && currentId != null) {
-        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === currentId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, variables) } : old);
+      if (optimisticUpdateMap?.detail !== false && targetId != null) {
+        queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, variables) } : old);
       }
-      return { previousQueries };
+      return { previousQueries, targetId, targetResource };
     },
-    onSuccess: (data: unknown) => {
+    onSuccess: (data: unknown, _vars: unknown, context: unknown) => {
+      const ctx = context as { targetId?: string | number; targetResource?: string } | undefined;
+      const targetId = ctx?.targetId ?? currentId;
+      const res = ctx?.targetResource ?? resource;
       if (successNotification !== false) notify({ type: 'success', message: typeof successNotification === 'string' ? successNotification : t('common.updateSuccess') });
-      audit({ action: 'update', resource, recordId: String(currentId) });
+      audit({ action: 'update', resource: res, recordId: String(targetId) });
       try {
         const lp = getLiveProvider();
-        if (lp?.publish) lp.publish({ type: 'UPDATE', resource, payload: { ids: currentId != null ? [currentId] : [] } });
+        if (lp?.publish) lp.publish({ type: 'UPDATE', resource: res, payload: { ids: targetId != null ? [targetId] : [] } });
       } catch { /* no live provider */ }
       onMutationSuccess?.(data);
       if (redirectOverride !== false) doRedirect(redirectOverride ?? redirectDefault);
     },
-    onSettled: (_data: unknown, error: unknown) => {
+    onSettled: (_data: unknown, error: unknown, _vars: unknown, context: unknown) => {
       if (error instanceof UndoError) return;
-      invalidateByScopes(queryClient, resource, invalidateScopes, ['list', 'many', 'detail'], currentId ?? undefined);
+      const ctx = context as { targetId?: string | number; targetResource?: string } | undefined;
+      const targetId = ctx?.targetId ?? currentId;
+      const res = ctx?.targetResource ?? resource;
+      invalidateByScopes(queryClient, res, invalidateScopes, ['list', 'many', 'detail'], targetId ?? undefined, options.dataProviderName);
     },
     onError: (error: unknown, _vars: unknown, context: unknown) => {
       const ctx = context as { previousQueries?: [unknown, unknown][] } | undefined;
@@ -404,9 +425,14 @@ export function useForm<
   // ─── Submit ─────────────────────────────────────────────────────
   async function submit(overrides?: { redirect?: 'list' | 'edit' | 'show' | false }) {
     if (autoSaveTimer) { clearTimeout(autoSaveTimer); autoSaveTimer = null; }
+    while (autoSaveInProgress) {
+      await new Promise(r => setTimeout(r, 50));
+    }
+    if (autoSaveTimer) { clearTimeout(autoSaveTimer); autoSaveTimer = null; }
+    autoSaveDirty = false;
     if (onSubmitFn) {
       let cancelled = false;
-      const result = onSubmitFn({ values, action, cancel: () => { cancelled = true; } });
+      const result = await onSubmitFn({ values, action, cancel: () => { cancelled = true; } });
       if (result === false || cancelled) return;
     }
 
@@ -424,12 +450,16 @@ export function useForm<
   // ─── AutoSave ───────────────────────────────────────────────────
   let autoSaveStatus = $state<'idle' | 'saving' | 'saved' | 'error'>('idle');
   let autoSaveTimer: ReturnType<typeof setTimeout> | null = null;
+  let autoSaveStatusTimer: ReturnType<typeof setTimeout> | null = null;
+  let autoSaveInProgress = $state(false);
+  let autoSaveDirty = false;
   let lastAutoSaveData = $state<unknown>(null);
   let lastAutoSaveError = $state<unknown>(null);
 
   $effect(() => {
     return () => {
       if (autoSaveTimer) clearTimeout(autoSaveTimer);
+      if (autoSaveStatusTimer) clearTimeout(autoSaveStatusTimer);
     };
   });
 
@@ -440,28 +470,42 @@ export function useForm<
     if (autoSaveTimer) clearTimeout(autoSaveTimer);
 
     const safeId = currentId;
+    const safeResource = resource;
+    const safeMeta = mutationMeta;
     autoSaveTimer = setTimeout(async () => {
+      if (autoSaveInProgress || createMut.isPending || updateMut.isPending) {
+        autoSaveDirty = true;
+        return;
+      }
       const finalValues = autoSaveOpts.onFinish ? autoSaveOpts.onFinish(values) : values;
       autoSaveStatus = 'saving';
+      autoSaveInProgress = true;
+      autoSaveDirty = false;
       try {
-        await provider.update<TData, TVariables>({ resource, id: safeId as string | number, variables: finalValues, meta: mutationMeta });
+        await provider.update<TData, TVariables>({ resource: safeResource, id: safeId as string | number, variables: finalValues, meta: safeMeta });
         const scopes = autoSaveOpts.invalidates ?? ['resourceAll'];
-        invalidateByScopes(queryClient, resource, scopes, ['resourceAll'], safeId ?? undefined);
+        invalidateByScopes(queryClient, safeResource, scopes, ['resourceAll'], safeId ?? undefined, options.dataProviderName);
         autoSaveStatus = 'saved';
         lastAutoSaveData = finalValues;
         lastAutoSaveError = null;
-        setTimeout(() => { autoSaveStatus = 'idle'; }, 2000);
+        initialValues = { ...finalValues } as TVariables;
+        tainted = {};
+        if (autoSaveStatusTimer) clearTimeout(autoSaveStatusTimer);
+        autoSaveStatusTimer = setTimeout(() => { autoSaveStatus = 'idle'; autoSaveStatusTimer = null; }, 2000);
       } catch (e) {
         autoSaveStatus = 'error';
         lastAutoSaveError = e;
         checkError(e);
+      } finally {
+        autoSaveInProgress = false;
+        if (autoSaveDirty) triggerAutoSave();
       }
     }, autoSaveOpts.debounce ?? 1000);
   }
 
   if (autoSaveOpts?.invalidateOnUnmount) {
     $effect(() => {
-      return () => queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource });
+      return () => queryClient.invalidateQueries({ predicate: (q) => q.queryKey[0] === options.dataProviderName && q.queryKey[1] === resource });
     });
   }
 

package/src/form-hooks.test.svelte.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi } from 'vitest';
+import { useForm } from './form-hooks.svelte';
+import { flushSync } from 'svelte';
+import { QueryClient } from '@tanstack/svelte-query';
+
+vi.mock('./context.svelte', () => ({
+  useDataProvider: () => ({
+    getOne: vi.fn(),
+    create: vi.fn().mockResolvedValue({ data: { id: 1 } }),
+    update: vi.fn().mockResolvedValue({ data: { id: 1 } })
+  }),
+  useResource: () => ({ name: 'posts' }),
+  getResource: () => ({ name: 'posts', primaryKey: 'id' }),
+  useRouterContext: () => ({ navigate: vi.fn() }),
+  useTranslate: () => (key: string) => key,
+  useNotification: () => ({ open: vi.fn(), close: vi.fn() })
+}));
+
+vi.mock('@tanstack/svelte-query', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual as any,
+    useQueryClient: () => new QueryClient(),
+    createQuery: () => ({ data: { data: { id: 1, title: 'Original' } }, isPending: false }),
+    createMutation: (opts: any) => ({
+      mutate: vi.fn((vars, callbacks) => {
+        if (opts.mutationFn) opts.mutationFn(vars);
+        if (callbacks?.onSuccess) callbacks.onSuccess({ data: {} });
+      }),
+      isPending: false
+    })
+  };
+});
+
+describe('useForm - Headless Svelte 5 Compatibility', () => {
+
+  it('preserves reactive proxy data bindings safely across Svelte boundaries', () => {
+    let form: ReturnType<typeof useForm>;
+
+    const cleanup = $effect.root(() => {
+      form = useForm({
+        action: 'create',
+        resource: 'posts'
+      });
+    });
+
+    flushSync();
+    
+    // Properly use setFieldValue which guarantees state sync in svadmin forms
+    form!.setFieldValue('title', 'Reactive Test');
+    
+    flushSync();
+    
+    // The internal $state proxy absorbs this mutation
+    expect(form!.values.title).toBe('Reactive Test');
+    
+    cleanup();
+  });
+
+  it('handles autoSave queuing correctly across reactive boundaries', () => {
+    let form: ReturnType<typeof useForm>;
+    
+    const cleanup = $effect.root(() => {
+      form = useForm({
+        action: 'edit',
+        resource: 'posts',
+        id: 1,
+        autoSave: { enabled: true, debounce: 0 }
+      });
+    });
+
+    flushSync();
+
+    form!.setFieldValue('title', 'Saved Title');
+    
+    flushSync();
+
+    expect(form!.mutation).toBeDefined();
+    expect((form!.mutation as any).isPending).toBeDefined();
+
+    cleanup();
+  });
+});