@svadmin/core 0.23.1 → 0.23.3

package/src/live-sse.ts

@@ -12,13 +12,9 @@
 import type { LiveProvider, LiveEvent } from './live.svelte';
 
 export interface SSELiveProviderOptions {
-  /** SSE endpoint URL, e.g. "https://api.example.com/events" */
   url: string;
-  /** Optional EventSource init options (e.g. withCredentials) */
   eventSourceInit?: EventSourceInit;
-  /** Optional callback when connection opens */
   onOpen?: () => void;
-  /** Optional callback for connection errors */
   onError?: (event: Event) => void;
 }
 
@@ -29,7 +25,7 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
   const subscribers = new Map<string, Set<Callback>>();
   let eventSource: EventSource | null = null;
   let status: 'connecting' | 'connected' | 'disconnected' = 'disconnected';
-  const registeredListeners = new Set<string>();
+  const namedListeners = new Map<string, EventListener>();
 
   function connect() {
     if (eventSource) return;
@@ -43,20 +39,17 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
       options.onOpen?.();
     };
 
-    // Listen for generic "message" events
     eventSource.onmessage = (msgEvent) => {
       dispatchEvent(msgEvent.data);
     };
 
     eventSource.onerror = (event) => {
-      // EventSource auto-reconnects by default
       if (eventSource?.readyState === EventSource.CLOSED) {
         status = 'disconnected';
       }
       options.onError?.(event);
     };
 
-    // Also listen for resource-specific named events
     for (const resource of subscribers.keys()) {
       if (resource !== '*') {
         addNamedListener(resource);
@@ -65,9 +58,8 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
   }
 
   function addNamedListener(resource: string) {
-    if (!eventSource || registeredListeners.has(resource)) return;
-    registeredListeners.add(resource);
-    eventSource.addEventListener(resource, ((event: MessageEvent) => {
+    if (!eventSource || namedListeners.has(resource)) return;
+    const listener = ((event: MessageEvent) => {
       try {
         const parsed = JSON.parse(event.data);
         const liveEvent: LiveEvent = {
@@ -79,7 +71,18 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
       } catch {
         // ignore non-JSON
       }
-    }) as EventListener);
+    }) as EventListener;
+    namedListeners.set(resource, listener);
+    eventSource.addEventListener(resource, listener);
+  }
+
+  function removeNamedListener(resource: string) {
+    const listener = namedListeners.get(resource);
+    if (!listener) return;
+    if (eventSource) {
+      eventSource.removeEventListener(resource, listener);
+    }
+    namedListeners.delete(resource);
   }
 
   function dispatchEvent(data: string) {
@@ -98,7 +101,6 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
     if (callbacks) {
       for (const cb of callbacks) cb(event);
     }
-    // Wildcard subscribers
     const wildcardCallbacks = subscribers.get('*');
     if (wildcardCallbacks) {
       for (const cb of wildcardCallbacks) cb(event);
@@ -111,7 +113,7 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
       eventSource = null;
     }
     status = 'disconnected';
-    registeredListeners.clear();
+    namedListeners.clear();
   }
 
   return {
@@ -123,11 +125,9 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
       }
       subscribers.get(resource)!.add(callback);
 
-      // Connect if not already
       if (!eventSource && typeof EventSource !== 'undefined') {
         connect();
       }
-      // Add named listener for this resource if connected
       if (eventSource && resource !== '*' && isNewResource) {
         addNamedListener(resource);
       }
@@ -136,7 +136,10 @@ export function createSSELiveProvider(options: SSELiveProviderOptions): LiveProv
         const callbacks = subscribers.get(resource);
         if (callbacks) {
           callbacks.delete(callback);
-          if (callbacks.size === 0) subscribers.delete(resource);
+          if (callbacks.size === 0) {
+            subscribers.delete(resource);
+            removeNamedListener(resource);
+          }
         }
         if (subscribers.size === 0) disconnect();
       };

package/src/live-websocket.ts

@@ -102,6 +102,7 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
 
   function disconnect() {
     intentionalClose = true;
+    reconnectAttempts = 0;
     if (reconnectTimer) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;

package/src/live.svelte.ts

@@ -31,7 +31,7 @@ export interface LiveProviderReconnectOptions {
 export function useLive(
   liveProvider: LiveProvider | (() => LiveProvider),
   resource: string | (() => string),
-  options?: { liveMode?: LiveMode | (() => LiveMode); onLiveEvent?: (event: LiveEvent) => void; liveParams?: Record<string, unknown> | (() => Record<string, unknown>) }
+  options?: { liveMode?: LiveMode | (() => LiveMode); onLiveEvent?: (event: LiveEvent) => void; liveParams?: Record<string, unknown> | (() => Record<string, unknown>); dataProviderName?: string }
 ): void {
   const queryClient = useQueryClient();
 
@@ -42,16 +42,24 @@ export function useLive(
     const liveParams = typeof options?.liveParams === 'function' ? options.liveParams() : options?.liveParams;
     if (liveMode === 'off') return;
 
-    const unsubscribe = lp.subscribe({
-      resource: res,
-      liveParams,
-      callback: (event) => {
-        options?.onLiveEvent?.(event);
-        if (liveMode === 'auto') {
-          queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res });
-        }
-      },
-    });
+    let unsubscribe: (() => void) | undefined;
+    try {
+      unsubscribe = lp.subscribe({
+        resource: res,
+        liveParams,
+        callback: (event) => {
+          options?.onLiveEvent?.(event);
+          if (liveMode === 'auto') {
+            const dpName = options?.dataProviderName;
+            const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpName;
+            queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === res });
+          }
+        },
+      });
+    } catch (e) {
+      console.warn('[svadmin] LiveProvider.subscribe failed:', e);
+      return;
+    }
     return unsubscribe;
   });
 }

package/src/mutation-hooks.svelte.ts

@@ -11,7 +11,7 @@ import { toast } from './toast.svelte';
 
 // ─── Helper: publish live events after mutations ────────────────
 
-function publishLiveEvent(resource: string, type: 'created' | 'updated' | 'deleted', ids?: (string | number)[]) {
+export function publishLiveEvent(resource: string, type: 'created' | 'updated' | 'deleted', ids?: (string | number)[]) {
   try {
     const liveProvider = getLiveProvider();
     if (liveProvider?.publish) {
@@ -36,21 +36,24 @@ export function invalidateByScopes(
   resource: string,
   scopes: string[] | false | undefined,
   defaults: string[],
-  id?: string | number
+  id?: string | number,
+  dataProviderName?: string
 ): void {
   if (scopes === false) return;
   const effectiveScopes = (scopes && scopes.length > 0) ? scopes : defaults;
+  const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dataProviderName;
   for (const scope of effectiveScopes) {
-    if (scope === 'list') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource && (q.queryKey[2] === 'list' || q.queryKey[2] === 'infiniteList' || q.queryKey[2] === 'select') });
-    else if (scope === 'many') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'many' });
-    else if ((scope === 'detail' || scope === 'one') && id != null) queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === id });
-    else if (scope === 'resourceAll') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource });
+    if (scope === 'list') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource && (q.queryKey[2] === 'list' || q.queryKey[2] === 'infiniteList' || q.queryKey[2] === 'select' || q.queryKey[2] === 'select-defaults') });
+    else if (scope === 'many') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource && q.queryKey[2] === 'many' });
+    else if ((scope === 'detail' || scope === 'one') && id != null) queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === id });
+    else if (scope === 'detail' || scope === 'one') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource && q.queryKey[2] === 'one' });
+    else if (scope === 'resourceAll') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource });
   }
 }
 
 export function deepMerge(target: any, source: any): any {
   if (!target || typeof target !== 'object') return source;
-  if (!source || typeof source !== 'object') return source;
+  if (!source || typeof source !== 'object') return target;
   if (Array.isArray(source) || source instanceof Date) return source;
   const result = { ...target };
   for (const key in source) {
@@ -127,14 +130,14 @@ export function useCreate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       audit({ action: 'create', resource: resName, recordId: String(newId) });
       publishLiveEvent(resName, 'created', newId != null ? [newId as string | number] : undefined);
       // Invalidation in onSuccess for create (refine pattern — no optimistic data to reconcile on error)
-      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many']);
+      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many'], undefined, params.dataProviderName);
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as Function)(data, params, context);
       }
     },
     onError: (error, params, context) => {
       checkError(error);
-      fireErrorNotification(params.errorNotification, 'Create failed', error);
+      fireErrorNotification(params.errorNotification, 'Create failed', error, params.resource ?? defaultResource);
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as Function)(error, params, context);
       }
@@ -218,10 +221,12 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (mutationMode === 'pessimistic') return { _svadmin_ctx: true, userContext };
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
+      const dpN = params.dataProviderName;
+      const dp = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
       
-      await queryClient.cancelQueries({ predicate: (q) => q.queryKey[1] === resName });
+      await queryClient.cancelQueries({ predicate: (q) => dp(q) && q.queryKey[1] === resName });
 
-      const previousQueries = queryClient.getQueriesData({ predicate: (q) => q.queryKey[1] === resName });
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName });
       
       const pk = getResource(resName).primaryKey ?? 'id';
       const updater = params.optimisticUpdateMap ?? { list: true, many: true, detail: true };
@@ -229,14 +234,14 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (updater.detail !== false) {
         const detailFn = updater.detail;
         if (typeof detailFn === 'function') {
-          queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: unknown) => detailFn(old, params.variables, targetId));
+          queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: unknown) => detailFn(old, params.variables, targetId));
         } else {
-          queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, params.variables) } : old);
+          queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, params.variables) } : old);
         }
       }
       
       if (updater.list !== false) {
-        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'list' }, (old: unknown) => {
+        queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'list' }, (old: unknown) => {
           if (typeof updater.list === 'function') return updater.list!(old, params.variables, targetId);
           if (!old || typeof old !== 'object' || !('data' in old)) return old;
           const o = old as { data: Record<string, unknown>[] };
@@ -245,7 +250,7 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       }
 
       if (updater.many !== false) {
-        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'many' }, (old: unknown) => {
+        queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'many' }, (old: unknown) => {
           if (typeof updater.many === 'function') return updater.many!(old, params.variables, targetId);
           if (!old || typeof old !== 'object' || !('data' in old)) return old;
           const o = old as { data: Record<string, unknown>[] };
@@ -270,7 +275,10 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many', 'detail'], targetId != null ? targetId : undefined);
+      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many', 'detail'], targetId != null ? targetId : undefined, params.dataProviderName);
+      if (typeof options.mutationOptions?.onSettled === 'function') {
+        (options.mutationOptions.onSettled as Function)(_data, error, params, undefined);
+      }
     },
     onError: (error, params, context: unknown) => {
       const ctx = context as MutationContext | undefined;
@@ -282,7 +290,7 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       checkError(error);
       const extractedCtx = ctx?._svadmin_ctx ? ctx.userContext : context;
-      fireErrorNotification(params.errorNotification, 'Update failed', error);
+      fireErrorNotification(params.errorNotification, 'Update failed', error, params.resource ?? defaultResource);
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as Function)(error, params, extractedCtx);
       }
@@ -361,23 +369,25 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (mutationMode === 'pessimistic') return { _svadmin_ctx: true, userContext };
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
+      const dpN = params.dataProviderName;
+      const dp = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
       
-      await queryClient.cancelQueries({ predicate: (q) => q.queryKey[1] === resName });
+      await queryClient.cancelQueries({ predicate: (q) => dp(q) && q.queryKey[1] === resName });
 
-      const previousQueries = queryClient.getQueriesData({ predicate: (q) => q.queryKey[1] === resName });
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName });
       
       const pk = getResource(resName).primaryKey ?? 'id';
       
-      if (targetId != null) queryClient.removeQueries({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
+      if (targetId != null) queryClient.removeQueries({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
 
-      queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'list' }, (old: unknown) => {
+      queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'list' }, (old: unknown) => {
         if (!old || typeof old !== 'object' || !('data' in old)) return old;
         const o = old as { data: Record<string, unknown>[]; total?: number };
         const filtered = o.data.filter((item) => String(item[pk]) !== String(targetId));
         return { ...o, data: filtered, total: (o.total ?? o.data.length) - (o.data.length - filtered.length) };
       });
 
-      queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'many' }, (old: unknown) => {
+      queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resName && q.queryKey[2] === 'many' }, (old: unknown) => {
         if (!old || typeof old !== 'object' || !('data' in old)) return old;
         const o = old as { data: Record<string, unknown>[] };
         return { ...o, data: o.data.filter((item) => String(item[pk]) !== String(targetId)) };
@@ -392,7 +402,7 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
 
       // Remove detail cache entry (refine pattern — no stale show page)
       if (targetId != null) {
-        queryClient.removeQueries({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
+        queryClient.removeQueries({ predicate: (q) => q.queryKey[0] === params.dataProviderName && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
       }
 
       fireSuccessNotification(params.successNotification, 'Deleted successfully', data.data, params.variables, resName);
@@ -405,7 +415,11 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
     onSettled: (_data, error, params) => {
       if (error instanceof UndoError) return;
       const resName = params.resource ?? defaultResource;
-      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many']);
+      const targetId = params.id ?? defaultId;
+      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many'], targetId != null ? targetId : undefined, params.dataProviderName);
+      if (typeof options.mutationOptions?.onSettled === 'function') {
+        (options.mutationOptions.onSettled as Function)(_data, error, params, undefined);
+      }
     },
     onError: (error, params, context: unknown) => {
       const ctx = context as MutationContext | undefined;
@@ -417,7 +431,7 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       checkError(error);
       const extractedCtx = ctx?._svadmin_ctx ? ctx.userContext : context;
-      fireErrorNotification(params.errorNotification, 'Delete failed', error);
+      fireErrorNotification(params.errorNotification, 'Delete failed', error, params.resource ?? defaultResource);
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as Function)(error, params, extractedCtx);
       }

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

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi } from 'vitest';
+import { useCreate, useUpdate, invalidateByScopes } from './mutation-hooks.svelte';
+import { flushSync } from 'svelte';
+import { QueryClient } from '@tanstack/svelte-query';
+
+vi.mock('./context.svelte', () => ({
+  useDataProvider: () => ({
+    getOne: vi.fn(),
+    getList: vi.fn(),
+    create: vi.fn().mockResolvedValue({ data: { id: 1 } }),
+    update: vi.fn().mockResolvedValue({ data: { id: 1 } })
+  }),
+  useResource: () => ({ name: 'posts' }),
+  getResource: (name: string) => ({ name, primaryKey: 'id' }),
+  useRouterContext: () => ({ navigate: vi.fn() }),
+  useTranslate: () => (key: string) => key,
+  useNotification: () => ({ open: vi.fn(), close: vi.fn() }),
+  getLiveProvider: () => undefined
+}));
+
+vi.mock('@tanstack/svelte-query', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual as any,
+    useQueryClient: () => new QueryClient(),
+    createMutation: (opts: any) => ({
+      mutate: vi.fn((vars, callbacks) => {
+        if (opts.mutationFn) opts.mutationFn(vars);
+        if (callbacks?.onSuccess) callbacks.onSuccess({ data: {} });
+      }),
+      isPending: false
+    })
+  };
+});
+
+describe('useCreate & useUpdate - Headless Svelte 5 Compatibility', () => {
+
+  it('safely binds useCreate and allows mutations over proxies', () => {
+    let createMutation: ReturnType<typeof useCreate>;
+    
+    const cleanup = $effect.root(() => {
+        createMutation = useCreate();
+    });
+
+    flushSync();
+    
+    expect(createMutation!.mutation.mutate).toBeDefined();
+    expect(createMutation!.mutation.isPending).toBe(false);
+
+    cleanup();
+  });
+
+  it('safely binds useUpdate and evaluates data updates', () => {
+    let updateMutation: ReturnType<typeof useUpdate>;
+    
+    const cleanup = $effect.root(() => {
+        updateMutation = useUpdate();
+    });
+
+    flushSync();
+    
+    expect(updateMutation!.mutation.mutate).toBeDefined();
+    expect(updateMutation!.mutation.isPending).toBe(false);
+
+    cleanup();
+  });
+});
+describe('mutation-hooks', () => {
+
+  describe('invalidateByScopes - Multi-Provider Cache Isolation', () => {
+    it('filters perfectly by dataProviderName when passed', () => {
+      const queryClient = new QueryClient();
+      queryClient.invalidateQueries = vi.fn(async () => {});
+
+      const resource = 'posts';
+      const providerName = 'secondaryProvider';
+      
+      // Act
+      invalidateByScopes(queryClient, resource, ['list'], ['list'], undefined, providerName);
+      
+      expect(queryClient.invalidateQueries).toHaveBeenCalled();
+      
+      // Assert predicate captures DataProvider scopes
+      const calls = (queryClient.invalidateQueries as ReturnType<typeof vi.fn>).mock.calls;
+      
+      // Using arbitrary mock objects simulating Query keys
+      const predicateFn = calls[0][0].predicate;
+      
+      const shouldPass = predicateFn({ queryKey: ['secondaryProvider', 'posts', 'list'] });
+      const shouldFail = predicateFn({ queryKey: ['default', 'posts', 'list'] });
+      const shouldFailResource = predicateFn({ queryKey: ['secondaryProvider', 'users', 'list'] });
+
+      expect(shouldPass).toBe(true);
+      expect(shouldFail).toBe(false);
+      expect(shouldFailResource).toBe(false);
+    });
+    
+    it('falls back to all providers when NO provider is specified', () => {
+      const queryClient = new QueryClient();
+      queryClient.invalidateQueries = vi.fn(async () => {});
+
+      // Act without providerName
+      invalidateByScopes(queryClient, 'posts', ['list'], ['list']);
+      
+      const predicateFn = (queryClient.invalidateQueries as ReturnType<typeof vi.fn>).mock.calls[0][0].predicate;
+      
+      const pass1 = predicateFn({ queryKey: ['default', 'posts', 'list'] });
+      const pass2 = predicateFn({ queryKey: ['custom', 'posts', 'list'] });
+      expect(pass1).toBe(true);
+      expect(pass2).toBe(true);
+    });
+  });
+
+});

package/src/notification.svelte.ts

@@ -26,13 +26,13 @@ export function notify(params: {
   if (notificationProvider) {
     notificationProvider.open(params);
   } else {
-    // Fallback to built-in toast
-    const { type, message } = params;
+    const { type, message, description } = params;
+    const fullMessage = description ? `${message}: ${description}` : message;
     switch (type) {
-      case 'success': toast.success(message, undefined, { key: params.key }); break;
-      case 'error': toast.error(message, undefined, { key: params.key }); break;
-      case 'warning': toast.warning(message, undefined, { key: params.key }); break;
-      case 'info': toast.info(message, undefined, { key: params.key }); break;
+      case 'success': toast.success(fullMessage, undefined, { key: params.key }); break;
+      case 'error': toast.error(fullMessage, undefined, { key: params.key }); break;
+      case 'warning': toast.warning(fullMessage, undefined, { key: params.key }); break;
+      case 'info': toast.info(fullMessage, undefined, { key: params.key }); break;
     }
   }
 }

package/src/options.svelte.ts

@@ -62,7 +62,7 @@ function createDefaultOptions(): AdminOptions {
     liveMode: 'auto',
     disableServerSideValidation: false,
     undoableTimeout: 5000,
-    textTransformers: defaultTextTransformers,
+    textTransformers: { ...defaultTextTransformers },
     redirect: { afterCreate: 'list', afterEdit: 'list', afterClone: 'list' },
     breadcrumb: 'default',
     disableRouteChangeHandler: false,

package/src/{permissions.ts → permissions.svelte.ts}

@@ -51,7 +51,7 @@ export interface AccessControlProvider {
 
 // ─── State ────────────────────────────────────────────────────
 
-let provider: AccessControlProvider | null = null;
+let provider: AccessControlProvider | null = $state(null);
 
 // ─── API ──────────────────────────────────────────────────────