@svadmin/core 0.11.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.11.0",
+  "version": "0.14.0",
   "description": "Core SDK — hooks, types, context, i18n, permissions, router",
   "type": "module",
   "sideEffects": false,

package/src/auth-hooks.svelte.ts

@@ -290,3 +290,61 @@ export function usePermissions<T = unknown>() {
     get error() { return error; },
   };
 }
+
+// ─── useHasPermission ────────────────────────────────────────
+
+/**
+ * Reactive permission checker — returns a closure that re-evaluates
+ * when the underlying permissions data changes.
+ *
+ * Works with Casbin-style permission arrays, Sets, or permission objects.
+ * The returned function is safe to use inside `$derived()` for reactive UI updates.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useHasPermission } from '@svadmin/core';
+ *
+ *   const hasPermission = useHasPermission();
+ *   // ✅ Reactive — UI updates when permissions finish loading
+ *   const canDelete = $derived(hasPermission('admin'));
+ *   const canExport = $derived(hasPermission('data:export'));
+ * </script>
+ *
+ * {#if canDelete}
+ *   <Button variant="destructive">Delete</Button>
+ * {/if}
+ * ```
+ */
+export function useHasPermission() {
+  const provider = getAuthProvider();
+  let permissions = $state<unknown>(null);
+  let loaded = $state(false);
+
+  if (provider?.getPermissions) {
+    provider.getPermissions().then(p => {
+      permissions = p;
+      loaded = true;
+    }).catch(err => {
+      console.warn('[svadmin] useHasPermission: getPermissions failed', err);
+      loaded = true;
+    });
+  } else {
+    loaded = true;
+  }
+
+  /**
+   * Check if the current user has a specific permission.
+   * Supports: `string[]`, `Set<string>`, `Record<string, boolean>`, or any object with `.includes` / `.has`.
+   */
+  function hasPermission(perm: string): boolean {
+    if (!loaded || permissions == null) return false;
+    if (Array.isArray(permissions)) return permissions.includes(perm);
+    if (permissions instanceof Set) return (permissions as Set<string>).has(perm);
+    if (typeof permissions === 'object') return !!(permissions as Record<string, boolean>)[perm];
+    return false;
+  }
+
+  return hasPermission;
+}
+

package/src/context.svelte.ts

@@ -112,7 +112,7 @@ export function getRouterProvider(): RouterProvider | undefined {
 
 // ─── Live Provider ──────────────────────────────────────────────
 
-let liveProviderState: import('./live.svelte').LiveProvider | undefined = undefined;
+let liveProviderState = $state<import('./live.svelte').LiveProvider | undefined>(undefined);
 
 export function setLiveProvider(provider: import('./live.svelte').LiveProvider): void {
   liveProviderState = provider;

package/src/form-hooks.svelte.ts

@@ -1,6 +1,6 @@
 import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed.svelte';
-import { getAdminOptions } from './options';
+import { getAdminOptions } from './options.svelte';
 import { getDataProviderForResource } from './context.svelte';
 import { createQuery, createMutation } from '@tanstack/svelte-query';
 import { toast } from './toast.svelte';
@@ -10,21 +10,48 @@ import { navigate } from './router';
 import { HttpError } from './types';
 import type { BaseRecord, MutationMode, KnownResources } from './types';
 
-export interface UseFormOptions<TQueryFnData extends BaseRecord = BaseRecord, TError = HttpError, TVariables = Record<string, unknown>, TData extends BaseRecord = TQueryFnData> {
+// ─── Types ───────────────────────────────────────────────────────────
+
+export interface UseFormOptions<
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
+  TError = HttpError,
+> {
   resource?: KnownResources;
   action?: 'create' | 'edit' | 'clone';
   id?: string | number;
   redirect?: 'list' | 'edit' | 'show' | false;
+
+  /** Initial values for the form. Merged with query data in edit mode (query wins). */
+  defaultValues?: TVariables;
+
+  // ─── Validation ───────────────────────────────────────────────
+  /** Full-form validator. Returns field→error map or null. */
+  validate?: (values: TVariables) => Record<string, string> | null;
+  /** Per-field validator for real-time validation. */
+  validateField?: (field: string, value: unknown, values: TVariables) => string | null;
+
+  // ─── Notifications ────────────────────────────────────────────
   successNotification?: string | false;
   errorNotification?: string | false;
-  dataProviderName?: string;
+
+  // ─── Callbacks ────────────────────────────────────────────────
   onMutationSuccess?: (data: unknown) => void;
   onMutationError?: (error: Error) => void;
+  /** Called every time a field value changes. */
+  onChange?: (event: { field: string; value: unknown; values: TVariables }) => void;
+  /** Called before mutation. Return false or call cancel() to prevent submission. */
+  onSubmit?: (ctx: { values: TVariables; action: 'create' | 'edit' | 'clone'; cancel: () => void }) => void | boolean;
+
+  // ─── Meta ─────────────────────────────────────────────────────
   meta?: Record<string, unknown>;
   queryMeta?: Record<string, unknown>;
   mutationMeta?: Record<string, unknown>;
+
+  // ─── Server validation ────────────────────────────────────────
   disableServerSideValidation?: boolean;
-  validate?: (values: TVariables) => Record<string, string> | null;
+
+  // ─── AutoSave ─────────────────────────────────────────────────
   autoSave?: {
     enabled: boolean;
     debounce?: number;
@@ -32,6 +59,8 @@ export interface UseFormOptions<TQueryFnData extends BaseRecord = BaseRecord, TE
     invalidateOnUnmount?: boolean;
     invalidates?: string[];
   };
+
+  // ─── Mutation behavior ────────────────────────────────────────
   mutationMode?: MutationMode;
   undoableTimeout?: number;
   invalidates?: string[] | false;
@@ -39,58 +68,95 @@ export interface UseFormOptions<TQueryFnData extends BaseRecord = BaseRecord, TE
     list?: boolean | ((previous: unknown, variables: TVariables, id?: string | number) => unknown);
     detail?: boolean | ((previous: unknown, variables: TVariables, id?: string | number) => unknown);
   };
+
+  // ─── Query config ─────────────────────────────────────────────
   queryOptions?: { staleTime?: number; enabled?: boolean };
   createMutationOptions?: Record<string, unknown>;
   updateMutationOptions?: Record<string, unknown>;
+
+  /** DataProvider to use for this form */
+  dataProviderName?: string;
+
   warnWhenUnsavedChanges?: boolean;
 }
 
-export type UseFormResult<TQueryFnData extends BaseRecord = BaseRecord, TError = HttpError, TVariables = Record<string, unknown>, TData extends BaseRecord = TQueryFnData> = {
-  readonly query: unknown;
-  readonly mutation: unknown;
-  readonly formLoading: boolean;
+export interface UseFormReturn<
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
+> {
+  // ─── Form values (single source of truth) ─────────────────────
+  /** Reactive form values. Read/write directly. */
+  readonly values: TVariables;
+  /** Set a single field value. Tracks tainted state and fires onChange. */
+  setFieldValue: (field: string, value: unknown, opts?: { taint?: boolean }) => void;
+  /** Bulk-set multiple field values. */
+  setValues: (newValues: Partial<TVariables>, opts?: { taint?: boolean }) => void;
+
+  // ─── Tainted (dirty) ──────────────────────────────────────────
+  readonly tainted: Record<string, boolean>;
+  isTainted: (field?: string) => boolean;
+
+  // ─── Errors ───────────────────────────────────────────────────
   readonly errors: Record<string, string>;
   setFieldError: (field: string, message: string) => void;
-  clearErrors: () => void;
   clearFieldError: (field: string) => void;
-  onFinish: (values: TVariables, finishOptions?: { redirect?: 'list' | 'edit' | 'show' | false }) => Promise<void>;
-  onFinishAutoSave: (values: TVariables) => Promise<void>;
-  triggerAutoSave: (values: TVariables) => void;
-  readonly autoSaveStatus: 'idle' | 'saving' | 'saved' | 'error';
+  clearErrors: () => void;
+  /** Validate a single field. Sets/clears the field error. Returns the error or null. */
+  validateField: (field: string) => string | null;
+
+  // ─── Submission ───────────────────────────────────────────────
+  /** Submit the form. Validates → onSubmit hook → mutation → redirect. */
+  submit: (overrides?: { redirect?: 'list' | 'edit' | 'show' | false }) => Promise<void>;
+  /** Reset form to initial/query values. Clears tainted and errors. */
+  reset: () => void;
+
+  // ─── State ────────────────────────────────────────────────────
+  readonly loading: boolean;
+  readonly submitting: boolean;
   readonly resource: string;
   readonly action: 'create' | 'edit' | 'clone';
   readonly id: string | number | undefined;
   setId: (newId: string | number) => void;
   readonly mutationMode: MutationMode;
   redirect: (to: 'list' | 'edit' | 'show' | false) => void;
-  readonly autoSaveProps: { status: 'idle' | 'loading' | 'success' | 'error'; data: unknown; error: unknown };
-};
+
+  // ─── AutoSave ─────────────────────────────────────────────────
+  triggerAutoSave: () => void;
+  readonly autoSave: { status: 'idle' | 'saving' | 'saved' | 'error'; data: unknown; error: unknown };
+
+  // ─── Raw query/mutation (escape hatch) ────────────────────────
+  readonly query: ReturnType<typeof createQuery> | null;
+  readonly mutation: ReturnType<typeof createMutation>;
+}
+
+// ─── Implementation ──────────────────────────────────────────────────
 
 export function useForm<
-  TQueryFnData extends BaseRecord = BaseRecord,
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
   TError = HttpError,
-  TVariables = Record<string, unknown>,
-  TData extends BaseRecord = TQueryFnData
->(options: UseFormOptions<TQueryFnData, TError, TVariables, TData> = {}): UseFormResult<TQueryFnData, TError, TVariables, TData> {
+>(options: UseFormOptions<TVariables, TData, TError> = {} as UseFormOptions<TVariables, TData, TError>): UseFormReturn<TVariables, TData> {
   const queryClient = useQueryClient();
   const parsed = useParsed();
   const adminOptions = getAdminOptions();
-  
+
   const resource = options.resource ?? parsed.resource ?? '';
   const action = options.action ?? (parsed.action === 'list' ? 'create' : parsed.action as 'create' | 'edit' | 'clone') ?? 'create';
   let currentId = $state<string | number | undefined>(options.id ?? parsed.id);
-  
+
   const {
     redirect: redirectDefault = 'list',
     successNotification, errorNotification,
     onMutationSuccess, onMutationError,
     meta: hookMeta, queryMeta: hookQueryMeta, mutationMeta: hookMutationMeta,
-    disableServerSideValidation, validate, autoSave,
+    disableServerSideValidation, autoSave: autoSaveOpts,
     mutationMode = adminOptions.mutationMode ?? 'pessimistic',
     undoableTimeout = adminOptions.undoableTimeout ?? 5000,
     dataProviderName, invalidates: invalidateScopes,
     optimisticUpdateMap,
     queryOptions,
+    onChange: onChangeFn,
+    onSubmit: onSubmitFn,
   } = options;
 
   const provider = getDataProviderForResource(resource, dataProviderName);
@@ -100,13 +166,61 @@ export function useForm<
 
   function setId(newId: string | number) { currentId = newId; }
 
+  // ─── Form values (single source of truth) ───────────────────────
+  let values = $state<TVariables>((options.defaultValues ?? {}) as TVariables);
+  let initialValues = $state<TVariables>((options.defaultValues ?? {}) as TVariables);
+
+  function setFieldValue(field: string, value: unknown, opts?: { taint?: boolean }) {
+    values = { ...values, [field]: value } as TVariables;
+    const shouldTaint = opts?.taint ?? true;
+    if (shouldTaint) tainted = { ...tainted, [field]: true };
+    // Clear field error on change
+    if (errors[field]) clearFieldError(field);
+    onChangeFn?.({ field, value, values });
+  }
+
+  function setValues(newValues: Partial<TVariables>, opts?: { taint?: boolean }) {
+    values = { ...values, ...newValues } as TVariables;
+    const shouldTaint = opts?.taint ?? true;
+    if (shouldTaint) {
+      const newTainted = { ...tainted };
+      for (const key of Object.keys(newValues)) newTainted[key] = true;
+      tainted = newTainted;
+    }
+  }
+
+  // ─── Tainted (dirty) state ──────────────────────────────────────
+  let tainted = $state<Record<string, boolean>>({});
+
+  function isTainted(field?: string): boolean {
+    if (field !== undefined) return !!tainted[field];
+    return Object.values(tainted).some(Boolean);
+  }
+
+  // ─── Errors ─────────────────────────────────────────────────────
   let errors = $state<Record<string, string>>({});
+
   function setFieldError(field: string, message: string) { errors = { ...errors, [field]: message }; }
   function clearErrors() { errors = {}; }
-  function clearFieldError(field: string) { delete errors[field]; }
+  function clearFieldError(field: string) {
+    const next = { ...errors };
+    delete next[field];
+    errors = next;
+  }
 
-  function runValidation(values: TVariables): boolean {
+  function doValidateField(field: string): string | null {
+    const value = values[field];
+    if (options.validateField) {
+      const msg = options.validateField(field, value, values);
+      if (msg) { setFieldError(field, msg); return msg; }
+      else { clearFieldError(field); }
+    }
+    return null;
+  }
+
+  function runValidation(): boolean {
     clearErrors();
+    const validate = options.validate;
     if (validate) {
       const result = validate(values);
       if (result && Object.keys(result).length > 0) {
@@ -117,6 +231,14 @@ export function useForm<
     return true;
   }
 
+  // ─── Reset ──────────────────────────────────────────────────────
+  function reset() {
+    values = { ...initialValues } as TVariables;
+    tainted = {};
+    clearErrors();
+  }
+
+  // ─── Server error handling ──────────────────────────────────────
   function handleHttpError(error: Error) {
     if (error instanceof HttpError && error.errors && !disableServerSideValidation) {
       for (const [field, messages] of Object.entries(error.errors)) {
@@ -129,11 +251,12 @@ export function useForm<
     }
   }
 
+  // ─── Query (edit/clone mode) ────────────────────────────────────
   const query = (action === 'edit' || action === 'clone') && currentId != null
     ? createQuery(() => ({
         queryKey: [resource, 'one', currentId],
         queryFn: async () => {
-          const result = await provider.getOne<TQueryFnData>({ resource, id: currentId!, meta: queryMeta });
+          const result = await provider.getOne<BaseRecord>({ resource, id: currentId!, meta: queryMeta });
           return result.data;
         },
         enabled: (queryOptions?.enabled ?? true) && currentId != null,
@@ -141,13 +264,32 @@ export function useForm<
       }))
     : null;
 
+  // Auto-populate values from query data
+  let queryInitialized = false;
+  if (query) {
+    $effect.pre(() => {
+      if (queryInitialized) return;
+      const data = query.data as Record<string, unknown> | undefined;
+      if (data) {
+        // Merge: defaultValues < query data
+        const merged = { ...(options.defaultValues ?? {}), ...data } as TVariables;
+        values = merged;
+        initialValues = { ...merged } as TVariables;
+        queryInitialized = true;
+      }
+    });
+  }
+
+  // ─── Mutations ──────────────────────────────────────────────────
+  let redirectOverride: 'list' | 'edit' | 'show' | false | undefined;
+
   const createMut = createMutation(() => ({
     ...options.createMutationOptions,
     mutationFn: (variables: TVariables) => provider.create<TData, TVariables>({ resource, variables, meta: mutationMeta }),
     onSuccess: (data: { data: TData }) => {
       if (invalidateScopes !== false) queryClient.invalidateQueries({ queryKey: [resource] });
       if (successNotification !== false) toast.success(successNotification || t('common.createSuccess'));
-      audit({ action: 'create', resource, recordId: String((data.data as any).id) });
+      audit({ action: 'create', resource, recordId: String((data.data as Record<string, unknown>).id) });
       onMutationSuccess?.(data);
       if (redirectOverride !== false) doRedirect(redirectOverride ?? redirectDefault);
     },
@@ -167,73 +309,73 @@ export function useForm<
     onError: (error: Error) => { handleHttpError(error); onMutationError?.(error); },
   }));
 
-  let redirectOverride: 'list' | 'edit' | 'show' | false | undefined;
-
   function doRedirect(to: 'list' | 'edit' | 'show' | false) {
     if (to === 'list') navigate(`/${resource}`);
     else if (to === 'edit' && currentId) navigate(`/${resource}/edit/${currentId}`);
     else if (to === 'show' && currentId) navigate(`/${resource}/show/${currentId}`);
   }
 
-  async function onFinish(values: TVariables, finishOptions?: { redirect?: 'list' | 'edit' | 'show' | false }) {
-    if (!runValidation(values)) { toast.warning(t('validation.required')); return; }
-    redirectOverride = finishOptions?.redirect;
+  // ─── Submit ─────────────────────────────────────────────────────
+  async function submit(overrides?: { redirect?: 'list' | 'edit' | 'show' | false }) {
+    // onSubmit pre-hook
+    if (onSubmitFn) {
+      let cancelled = false;
+      const result = onSubmitFn({ values, action, cancel: () => { cancelled = true; } });
+      if (result === false || cancelled) return;
+    }
+
+    if (!runValidation()) { toast.warning(t('validation.required')); return; }
+    redirectOverride = overrides?.redirect;
     if (action === 'create' || action === 'clone') await createMut.mutateAsync(values);
     else await updateMut.mutateAsync(values);
+    // Untaint on success
+    tainted = {};
   }
 
-  async function onFinishAutoSave(values: TVariables) {
-    if (action === 'create' || action === 'clone') return; // Only autosave on edit
-    redirectOverride = false; // Never redirect on autoSave
-    await updateMut.mutateAsync(values);
-  }
-
+  // ─── AutoSave ───────────────────────────────────────────────────
   let autoSaveStatus = $state<'idle' | 'saving' | 'saved' | 'error'>('idle');
   let autoSaveTimer: ReturnType<typeof setTimeout> | null = null;
+  let lastAutoSaveData = $state<unknown>(null);
+  let lastAutoSaveError = $state<unknown>(null);
 
-  function triggerAutoSave(values: TVariables) {
-    if (!autoSave?.enabled || action === 'create') return;
+  function triggerAutoSave() {
+    if (!autoSaveOpts?.enabled || action === 'create') return;
     if (autoSaveTimer) clearTimeout(autoSaveTimer);
 
     autoSaveTimer = setTimeout(async () => {
-      const finalValues = autoSave.onFinish ? autoSave.onFinish(values) : values;
+      const finalValues = autoSaveOpts.onFinish ? autoSaveOpts.onFinish(values) : values;
       autoSaveStatus = 'saving';
       try {
         await provider.update<TData, TVariables>({ resource, id: currentId!, variables: finalValues, meta: mutationMeta });
-        const scopes = autoSave.invalidates ?? ['resourceAll'];
+        const scopes = autoSaveOpts.invalidates ?? ['resourceAll'];
         for (const scope of scopes) {
           if (scope === 'resourceAll') queryClient.invalidateQueries({ queryKey: [resource] });
           else if (scope === 'detail' && currentId) queryClient.invalidateQueries({ queryKey: [resource, 'one', currentId] });
           else if (scope === 'list') queryClient.invalidateQueries({ queryKey: [resource, 'list'] });
         }
         autoSaveStatus = 'saved';
-        lastAutoSaveData = undefined; // placeholder for returned data
+        lastAutoSaveData = undefined;
         lastAutoSaveError = null;
         setTimeout(() => { autoSaveStatus = 'idle'; }, 2000);
       } catch (e) {
         autoSaveStatus = 'error';
         lastAutoSaveError = e;
       }
-    }, autoSave.debounce ?? 1000);
+    }, autoSaveOpts.debounce ?? 1000);
   }
 
-  let lastAutoSaveData = $state<unknown>(null);
-  let lastAutoSaveError = $state<unknown>(null);
-
-  if (autoSave?.invalidateOnUnmount) {
+  if (autoSaveOpts?.invalidateOnUnmount) {
     $effect(() => {
       return () => queryClient.invalidateQueries({ queryKey: [resource] });
     });
   }
 
-  // warnWhenUnsavedChanges
+  // ─── warnWhenUnsavedChanges ─────────────────────────────────────
   const shouldWarn = options.warnWhenUnsavedChanges ?? adminOptions.warnWhenUnsavedChanges;
   if (shouldWarn && typeof window !== 'undefined') {
     $effect(() => {
+      if (!isTainted()) return;
       const handler = (e: BeforeUnloadEvent) => {
-        // Here we'd typically check a dirty state, but useForm itself doesn't track dirty fields.
-        // Usually the form library (svelte-forms etc) handles dirty state.
-        // Assuming we always warn if enabled for now.
         e.preventDefault();
         e.returnValue = '';
       };
@@ -242,25 +384,45 @@ export function useForm<
     });
   }
 
+  // ─── Return ─────────────────────────────────────────────────────
   return {
-    query,
-    get formLoading() { return (query?.isLoading ?? false) || createMut.isPending || updateMut.isPending; },
-    mutation: action === 'edit' ? updateMut : createMut,
-    onFinish,
-    onFinishAutoSave,
+    // Values
+    get values() { return values; },
+    setFieldValue,
+    setValues,
+
+    // Tainted
+    get tainted() { return tainted; },
+    isTainted,
+
+    // Errors
     get errors() { return errors; },
-    setFieldError, clearErrors, clearFieldError,
-    triggerAutoSave,
-    get autoSaveStatus() { return autoSaveStatus; },
+    setFieldError, clearFieldError, clearErrors,
+    validateField: doValidateField,
+
+    // Submission
+    submit,
+    reset,
+
+    // State
+    get loading() { return query?.isLoading ?? false; },
+    get submitting() { return createMut.isPending || updateMut.isPending; },
     resource, action,
     get id() { return currentId; },
     setId, mutationMode, redirect: doRedirect,
-    get autoSaveProps() {
+
+    // AutoSave
+    triggerAutoSave,
+    get autoSave() {
       return {
-        status: autoSaveStatus as 'idle' | 'loading' | 'success' | 'error',
+        status: autoSaveStatus as 'idle' | 'saving' | 'saved' | 'error',
         data: lastAutoSaveData,
         error: lastAutoSaveError,
       };
     },
+
+    // Raw escape hatches
+    query,
+    mutation: (action === 'edit' ? updateMut : createMut) as unknown as ReturnType<typeof createMutation>,
   };
 }

package/src/helpers.ts

@@ -2,7 +2,7 @@
 
 import type { Filter, Sort, CrudOperator } from './types';
 import { t } from './i18n.svelte';
-import { getTextTransformers } from './options';
+import { getTextTransformers } from './options.svelte';
 
 // ─── Table Helpers ────────────────────────────────────────────
 
@@ -155,3 +155,97 @@ export function generateDefaultDocumentTitle(options?: {
   const prefix = action ? (actionPrefixes[action] ?? '') : '';
   return `${prefix}${resourceLabel}${suffix}`;
 }
+
+// ─── Form Validation Derivation ─────────────────────────────────
+
+/**
+ * Derive a `useForm`-compatible `validate` function from `FieldDefinition[]`.
+ *
+ * Automatically validates:
+ * - `required` fields (non-empty check)
+ * - `type === 'email'` fields (basic email format)
+ * - `type === 'url'` fields (basic URL format)
+ * - `type === 'number'` fields (must be a valid number)
+ * - Custom per-field `field.validate()` callback
+ *
+ * This eliminates the need for hand-written Zod schemas in most CRUD scenarios.
+ *
+ * @example
+ * ```ts
+ * const form = useForm({
+ *   resource: 'users',
+ *   validate: deriveValidator(resource.fields),
+ * });
+ * ```
+ */
+export function deriveValidator(
+  fields: import('./types').FieldDefinition[],
+  options?: {
+    /** Only validate these field keys. Default: all fields. */
+    only?: string[];
+    /** Skip these field keys. */
+    except?: string[];
+  }
+): (values: Record<string, unknown>) => Record<string, string> | null {
+  return (values: Record<string, unknown>) => {
+    const errors: Record<string, string> = {};
+    const only = options?.only ? new Set(options.only) : null;
+    const except = options?.except ? new Set(options.except) : null;
+
+    for (const field of fields) {
+      if (only && !only.has(field.key)) continue;
+      if (except && except.has(field.key)) continue;
+
+      const value = values[field.key];
+
+      // Required check
+      if (field.required) {
+        if (value === undefined || value === null || value === '') {
+          errors[field.key] = t('validation.required');
+          continue;
+        }
+        // Empty array check for multi-value fields
+        if (Array.isArray(value) && value.length === 0 && (field.type === 'multiselect' || field.type === 'tags')) {
+          errors[field.key] = t('validation.required');
+          continue;
+        }
+      }
+
+      // Skip further checks for empty non-required fields
+      if (value === undefined || value === null || value === '') continue;
+
+      // Type-specific validation
+      switch (field.type) {
+        case 'email': {
+          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+          if (typeof value === 'string' && !emailRegex.test(value)) {
+            errors[field.key] = t('validation.email', { defaultValue: 'Invalid email address' });
+          }
+          break;
+        }
+        case 'url': {
+          try {
+            new URL(value as string);
+          } catch {
+            errors[field.key] = t('validation.url', { defaultValue: 'Invalid URL' });
+          }
+          break;
+        }
+        case 'number': {
+          if (typeof value === 'string' && isNaN(Number(value))) {
+            errors[field.key] = t('validation.number', { defaultValue: 'Must be a number' });
+          }
+          break;
+        }
+      }
+
+      // Custom per-field validator (always runs last, can override type checks)
+      if (field.validate && !errors[field.key]) {
+        const msg = field.validate(value);
+        if (msg) { errors[field.key] = msg; }
+      }
+    }
+
+    return Object.keys(errors).length > 0 ? errors : null;
+  };
+}

package/src/hooks.svelte.ts

@@ -10,7 +10,7 @@ export * from './routing-hooks.svelte';
 export * from './utility-hooks.svelte';
 
 // ─── Re-export types from options ─────────────────────────────────
-export type { InvalidateScope, OvertimeConfig } from './options';
+export type { InvalidateScope, OvertimeConfig } from './options.svelte';
 
 // ─── Export shared utilities ────────────────────────────────────────
 
@@ -22,7 +22,7 @@ export type { OvertimeResult, OvertimeOptions, NotificationConfig } from './hook
 // here as thin wrappers or stubs until they get their own modular files.
 
 import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from '@tanstack/svelte-query';
-import { getAdminOptions } from './options';
+import { getAdminOptions } from './options.svelte';
 import { getDataProviderForResource, getDataProvider } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
 import { createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
@@ -356,10 +356,3 @@ export function useThemedLayoutContext() {
   };
 }
 
-// ─── Logging hooks (legacy aliases) ─────────────────────────────────
-
-export function useLogList(options?: Partial<UseListOptions>) {
-  return useList({ resource: 'logs', ...options });
-}
-
-export const useLog = useLogList;

package/src/index.ts

@@ -20,7 +20,6 @@ export {
   useNavigation, useGo, useBack,
   useGetToPath, useLink,
   useResource,
-  useLog, useLogList,
   useModalForm, useDrawerForm, useModal,
   useOvertime, useRelation,
   useNotification, useDataProvider,
@@ -28,7 +27,7 @@ export {
 } from './hooks.svelte';
 export { matchRoute, navigate, currentPath, setActiveRouterProvider } from './router';
 export { readURLState, writeURLState } from './url-sync';
-export { setAccessControl, setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccess, canAccessAsync } from './permissions';
+export { setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccess, canAccessAsync } from './permissions';
 export { useLive, useSubscription, usePublish } from './live.svelte';
 export { toast } from './toast.svelte';
 export { notify, closeNotification, setNotificationProvider, getNotificationProvider } from './notification.svelte';
@@ -40,8 +39,8 @@ export type { ChatProvider, ChatMessage, ChatContext, ChatAction } from './chatP
 export { getTheme, setTheme, toggleTheme, getResolvedTheme, getColorTheme, setColorTheme, colorThemes, configureTheme, getThemeConfig, clearCssOverrides, builtinPresets, registerColorPreset, getColorPresets } from './theme.svelte';
 export type { ThemeMode, ColorTheme, ThemeStrategy, ThemeConfig, ColorPreset } from './theme.svelte';
 export { setUnsavedChanges, getUnsavedChanges, initUnsavedChangesNotifier } from './unsaved-changes.svelte';
-export { setAdminOptions, getAdminOptions, getTextTransformers } from './options';
-export type { AdminOptions, TextTransformers, OvertimeConfig } from './options';
+export { setAdminOptions, getAdminOptions, getTextTransformers } from './options.svelte';
+export type { AdminOptions, TextTransformers, OvertimeConfig } from './options.svelte';
 
 export * from './query-keys';
 export { HttpError } from './types';
@@ -64,9 +63,9 @@ export type {
   ResourceTypeMap, KnownResources, InferData,
   BaseRecord,
 } from './types';
-export type { InvalidateScope } from './options';
+export type { InvalidateScope } from './options.svelte';
 export type { LiveProvider, LiveEvent, LiveMode } from './live.svelte';
-export type { Action, CanParams, CanResult, AccessControlProvider, AccessControlResult, AccessControlFn } from './permissions';
+export type { Action, CanParams, CanResult, AccessControlProvider } from './permissions';
 export type { AuditEntry, AuditHandler } from './audit';
 export { useCan } from './useCan';
 export type { UseCanOptions, UseCanResult } from './useCan';
@@ -79,7 +78,7 @@ export {
   useLogin, useLogout,
   useRegister, useForgotPassword, useUpdatePassword,
   useGetIdentity, useIsAuthenticated,
-  useOnError, usePermissions,
+  useOnError, usePermissions, useHasPermission,
 } from './auth-hooks.svelte';
 export { useParsed } from './useParsed.svelte';
 export * from './useStepsForm.svelte';
@@ -97,6 +96,7 @@ export {
   getDefaultFilter, getDefaultSortOrder,
   unionFilters, unionSorters,
   file2Base64, generateDefaultDocumentTitle,
+  deriveValidator,
 } from './helpers';
 export { TableState } from './table-state.svelte';
 export type { TableStateOptions } from './table-state.svelte';

package/src/mutation-hooks.svelte.ts

@@ -1,5 +1,5 @@
 import { createMutation, useQueryClient } from '@tanstack/svelte-query';
-import { getAdminOptions } from './options';
+import { getAdminOptions } from './options.svelte';
 import { getDataProviderForResource } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
 import { audit } from './audit';
@@ -61,7 +61,7 @@ export function useCreate<TData extends BaseRecord = BaseRecord, TError = HttpEr
         queryClient.invalidateQueries({ queryKey: [resName] });
       }
       fireSuccessNotification(params.successNotification, 'Created successfully', data.data, params.variables, resName);
-      audit({ action: 'create', resource: resName, recordId: String((data.data as any).id) });
+      audit({ action: 'create', resource: resName, recordId: String((data.data as Record<string, unknown>).id) });
     },
     onError: (error, params) => {
       fireErrorNotification(params.errorNotification, 'Create failed', error);

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

@@ -1,13 +1,10 @@
-// Global admin options — centralized configuration
+// Global admin options — centralized configuration (module-level $state)
 // Provides defaults that individual hooks can override
 
-import { setContext, getContext } from 'svelte';
 import type { MutationMode } from './types';
 
 export type InvalidateScope = 'all' | 'resourceAll' | 'detail' | 'list' | false | string[];
 
-const OPTIONS_KEY = Symbol('admin-options');
-
 export interface TextTransformers {
   humanize: (text: string) => string;
   plural: (text: string) => string;
@@ -27,7 +24,6 @@ export interface AdminOptions {
   liveMode?: 'auto' | 'manual' | 'off';
   disableServerSideValidation?: boolean;
   undoableTimeout?: number;
-  // v0.2.26 additions
   textTransformers?: Partial<TextTransformers>;
   redirect?: {
     afterCreate?: 'list' | 'edit' | 'show' | false;
@@ -36,7 +32,7 @@ export interface AdminOptions {
   };
   reactQuery?: {
     staleTime?: number;
-    cacheTime?: number;
+    gcTime?: number;
     refetchOnWindowFocus?: boolean;
   };
   title?: {
@@ -69,22 +65,18 @@ const defaultOptions: AdminOptions = {
   disableRouteChangeHandler: false,
 };
 
+let adminOptions = $state<AdminOptions>(defaultOptions);
+
 export function setAdminOptions(options: AdminOptions): void {
-  const merged = {
+  adminOptions = {
     ...defaultOptions,
     ...options,
     textTransformers: { ...defaultTextTransformers, ...options.textTransformers },
   };
-  setContext(OPTIONS_KEY, merged);
 }
 
 export function getAdminOptions(): AdminOptions {
-  try {
-    const opts = getContext<AdminOptions>(OPTIONS_KEY);
-    return opts ?? defaultOptions;
-  } catch {
-    return defaultOptions;
-  }
+  return adminOptions;
 }
 
 /** Get the resolved text transformers (always returns full set) */
@@ -92,4 +84,3 @@ export function getTextTransformers(): TextTransformers {
   const opts = getAdminOptions();
   return { ...defaultTextTransformers, ...opts.textTransformers };
 }
-

package/src/permissions.test.ts

@@ -1,56 +1,60 @@
 // Unit tests for permissions module
 import { describe, test, expect, beforeEach } from 'bun:test';
-import { setAccessControl, setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccess, canAccessAsync } from './permissions';
+import { setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccess, canAccessAsync } from './permissions';
 import type { Action, AccessControlProvider } from './permissions';
 
 describe('permissions', () => {
   beforeEach(() => {
-    // Reset to no access control (allow all)
-    setAccessControl((() => ({ can: true })) as Parameters<typeof setAccessControl>[0]);
+    // Reset to a permissive provider
+    setAccessControlProvider({
+      can: async () => ({ can: true }),
+    });
   });
 
-  test('canAccess returns { can: true } when no deny rules', () => {
+  test('canAccess returns { can: true } when provider is async (warns)', () => {
+    // canAccess is sync but provider.can() is async — should default to { can: true }
     const result = canAccess('posts', 'list' as Action);
     expect(result.can).toBe(true);
   });
 
-  test('canAccess respects deny rule', () => {
-    setAccessControl((_resource: string, action: Action) => {
-      if (action === 'delete') return { can: false, reason: 'Denied' };
-      return { can: true };
+  test('canAccessAsync respects deny rule', async () => {
+    setAccessControlProvider({
+      can: async ({ action }) => {
+        if (action === 'delete') return { can: false, reason: 'Denied' };
+        return { can: true };
+      },
     });
-    expect(canAccess('posts', 'delete')).toEqual({ can: false, reason: 'Denied' });
-    expect(canAccess('posts', 'list')).toEqual({ can: true });
-  });
-
-  test('canAccess returns { can: true } when async fn used sync', () => {
-    setAccessControl(async () => ({ can: false }));
-    // Should warn and default to { can: true }
-    const result = canAccess('posts', 'list');
-    expect(result.can).toBe(true);
+    expect(await canAccessAsync('posts', 'delete')).toEqual({ can: false, reason: 'Denied' });
+    expect(await canAccessAsync('posts', 'list')).toEqual({ can: true });
   });
 
   test('canAccessAsync resolves with allowed status', async () => {
-    setAccessControl(async () => ({ can: true }));
+    setAccessControlProvider({
+      can: async () => ({ can: true }),
+    });
     const result = await canAccessAsync('posts', 'edit');
     expect(result.can).toBe(true);
   });
 
   test('canAccessAsync resolves with denied status', async () => {
-    setAccessControl(async (_r: string, _a: Action) => ({ can: false, reason: 'No permission' }));
+    setAccessControlProvider({
+      can: async () => ({ can: false, reason: 'No permission' }),
+    });
     const result = await canAccessAsync('users', 'delete');
     expect(result.can).toBe(false);
     expect(result.reason).toBe('No permission');
   });
 
-  test('resource-specific rules', () => {
-    setAccessControl((resource: string, action: Action) => {
-      if (resource === 'users' && action === 'delete') return { can: false, reason: 'Cannot delete users' };
-      return { can: true };
+  test('resource-specific rules', async () => {
+    setAccessControlProvider({
+      can: async ({ resource, action }) => {
+        if (resource === 'users' && action === 'delete') return { can: false, reason: 'Cannot delete users' };
+        return { can: true };
+      },
     });
-    expect(canAccess('users', 'delete').can).toBe(false);
-    expect(canAccess('users', 'list').can).toBe(true);
-    expect(canAccess('posts', 'delete').can).toBe(true);
+    expect((await canAccessAsync('users', 'delete')).can).toBe(false);
+    expect((await canAccessAsync('users', 'list')).can).toBe(true);
+    expect((await canAccessAsync('posts', 'delete')).can).toBe(true);
   });
 });
 

package/src/permissions.ts

@@ -16,8 +16,7 @@ export interface CanResult {
   reason?: string;
 }
 
-/** @deprecated Use `CanResult` instead */
-export type AccessControlResult = CanResult;
+
 
 /**
  * Formal Access Control Provider interface.
@@ -50,17 +49,9 @@ export interface AccessControlProvider {
   };
 }
 
-/** @deprecated Use `AccessControlProvider['can']` instead */
-export type AccessControlFn = (
-  resource: string,
-  action: Action,
-  params?: Record<string, unknown>,
-) => CanResult | Promise<CanResult>;
-
 // ─── State ────────────────────────────────────────────────────
 
 let provider: AccessControlProvider | null = null;
-let legacyFn: AccessControlFn | null = null;
 
 // ─── API ──────────────────────────────────────────────────────
 
@@ -69,21 +60,6 @@ let legacyFn: AccessControlFn | null = null;
  */
 export function setAccessControlProvider(p: AccessControlProvider): void {
   provider = p;
-  legacyFn = null;
-}
-
-/**
- * @deprecated Use `setAccessControlProvider()` with full `AccessControlProvider` interface.
- * Legacy API preserved for backward compatibility.
- */
-export function setAccessControl(fn: AccessControlFn): void {
-  legacyFn = fn;
-  provider = {
-    can: async ({ resource, action, params }) => {
-      const result = fn(resource, action, params);
-      return result instanceof Promise ? result : Promise.resolve(result);
-    },
-  };
 }
 
 /** Get the current AccessControlProvider (or null) */
@@ -97,23 +73,12 @@ export function getAccessControlOptions() {
 }
 
 /**
- * Synchronous access check. Returns `{ can: true }` if no provider/fn is set.
- * When a legacy sync fn is registered via `setAccessControl()`, this calls it synchronously.
- * When only a provider is registered, this warns if provider.can() returns a Promise.
+ * Synchronous access check. Returns `{ can: true }` if no provider is set.
+ * When a provider is registered, this warns since provider.can() is always async.
  */
 export function canAccess(resource: string, action: Action, params?: Record<string, unknown>): CanResult {
-  // Fast path: use legacy sync fn if available
-  if (legacyFn) {
-    const result = legacyFn(resource, action, params);
-    if (result instanceof Promise) {
-      console.warn('[permissions] canAccess called synchronously but accessControlFn returned a Promise. Defaulting to { can: true }. Use canAccessAsync() instead.');
-      return { can: true };
-    }
-    return result;
-  }
   if (!provider) return { can: true };
-  // Provider path (always async) — warn
-  console.warn('[permissions] canAccess called synchronously but provider.can() returned a Promise. Defaulting to { can: true }. Use canAccessAsync() instead.');
+  console.warn('[permissions] canAccess called synchronously but provider.can() is async. Defaulting to { can: true }. Use canAccessAsync() instead.');
   return { can: true };
 }
 
@@ -121,9 +86,6 @@ export function canAccess(resource: string, action: Action, params?: Record<stri
  * Async access check. Preferred over `canAccess()`.
  */
 export async function canAccessAsync(resource: string, action: Action, params?: Record<string, unknown>): Promise<CanResult> {
-  if (legacyFn) {
-    return legacyFn(resource, action, params);
-  }
   if (!provider) return { can: true };
   return provider.can({ resource, action, params });
 }

package/src/query-hooks.svelte.ts

@@ -1,5 +1,5 @@
 import { createQuery, createInfiniteQuery } from '@tanstack/svelte-query';
-import { getAdminOptions } from './options';
+import { getAdminOptions } from './options.svelte';
 import { getDataProviderForResource, getDataProvider, getLiveProvider } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
 import {
@@ -25,7 +25,7 @@ export interface UseListOptions<TData extends BaseRecord = BaseRecord, TError =
   filters?: Filter[];
   meta?: Record<string, unknown>;
   dataProviderName?: string;
-  queryOptions?: { staleTime?: number; enabled?: boolean; cacheTime?: number; refetchOnWindowFocus?: boolean };
+  queryOptions?: { staleTime?: number; enabled?: boolean; gcTime?: number; refetchOnWindowFocus?: boolean };
   successNotification?: NotificationConfig;
   errorNotification?: NotificationConfig;
   liveMode?: LiveMode;
@@ -56,7 +56,7 @@ export function useList<TData extends BaseRecord = BaseRecord, TError = HttpErro
     },
     enabled: queryOptions?.enabled ?? true,
     staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-    gcTime: queryOptions?.cacheTime ?? adminOptions.reactQuery?.cacheTime,
+    gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
     refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
   }));
 
@@ -95,7 +95,7 @@ export interface UseOneOptions<TData extends BaseRecord = BaseRecord, TError = H
   id?: string | number;
   meta?: Record<string, unknown>;
   dataProviderName?: string;
-  queryOptions?: { staleTime?: number; enabled?: boolean; cacheTime?: number; refetchOnWindowFocus?: boolean };
+  queryOptions?: { staleTime?: number; enabled?: boolean; gcTime?: number; refetchOnWindowFocus?: boolean };
   successNotification?: NotificationConfig;
   errorNotification?: NotificationConfig;
   liveMode?: LiveMode;
@@ -126,7 +126,7 @@ export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError
     },
     enabled: (queryOptions?.enabled ?? true) && id != null,
     staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-    gcTime: queryOptions?.cacheTime ?? adminOptions.reactQuery?.cacheTime,
+    gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
   }));
 
   const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
@@ -170,7 +170,7 @@ export interface UseManyOptions<TData extends BaseRecord = BaseRecord, TError =
   ids: (string | number)[];
   meta?: Record<string, unknown>;
   dataProviderName?: string;
-  queryOptions?: { staleTime?: number; enabled?: boolean; cacheTime?: number; refetchOnWindowFocus?: boolean };
+  queryOptions?: { staleTime?: number; enabled?: boolean; gcTime?: number; refetchOnWindowFocus?: boolean };
   successNotification?: NotificationConfig;
   errorNotification?: NotificationConfig;
   liveMode?: LiveMode;

package/src/router.ts

@@ -57,7 +57,7 @@ export function navigate(path: string): void {
   if (_routerProvider) {
     _routerProvider.go({ to: path });
   } else {
-    window.location.hash = path.startsWith('#') ? path : path;
+    window.location.hash = '#' + path.replace(/^#/, '');
   }
 }
 

package/src/table-hooks.svelte.ts

@@ -138,13 +138,11 @@ export function useTable<
 
   return {
     query,
-    tableQuery: query,
     get overtime() { return overtime; },
     get pagination() { return pagination; },
     get sorters() { return currentSorters; },
     get filters() { return currentFilters; },
     setSorters, setFilters, setPage, setPageSize,
-    setCurrentPage: setPage,
     createLinkForSyncWithLocation,
     get totalPages() {
       // ts-expect-error reactive access

package/src/types.ts

@@ -25,7 +25,7 @@ export class UndoError extends Error {
 
 // ─── Base Types ───────────────────────────────────────────────
 
-export type BaseRecord = any;
+export type BaseRecord = Record<string, unknown>;
 
 // ─── DataProvider ─────────────────────────────────────────────
 
@@ -288,7 +288,8 @@ export interface FieldDefinition {
   key: string;
   label: string;
   type: 'text' | 'number' | 'boolean' | 'date' | 'select' | 'multiselect' | 'tags'
-    | 'textarea' | 'richtext' | 'image' | 'images' | 'json' | 'relation' | 'color' | 'url' | 'email' | 'phone';
+    | 'textarea' | 'richtext' | 'image' | 'images' | 'json' | 'relation' | 'color'
+    | 'url' | 'email' | 'phone' | 'file' | 'markdown' | 'password';
   required?: boolean;
   searchable?: boolean;
   sortable?: boolean;

package/src/useStepsForm.svelte.ts

@@ -1,25 +1,22 @@
 import { useForm } from './form-hooks.svelte';
-import type { UseFormOptions, UseFormResult } from './form-hooks.svelte';
+import type { UseFormOptions, UseFormReturn } from './form-hooks.svelte';
 import type { BaseRecord, HttpError } from './types';
 
 export interface UseStepsFormOptions<
-  TQueryFnData extends BaseRecord = BaseRecord,
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
   TError = HttpError,
-  TVariables = Record<string, unknown>,
-  TData extends BaseRecord = TQueryFnData
-> extends UseFormOptions<TQueryFnData, TError, TVariables, TData> {
+> extends UseFormOptions<TVariables, TData, TError> {
   /** Default step index. Starts at 0. */
   defaultStep?: number;
   /** Validate the form when navigating back? */
   isBackValidate?: boolean;
 }
 
-export interface UseStepsFormResult<
-  TQueryFnData extends BaseRecord = BaseRecord,
-  TError = HttpError,
-  TVariables = Record<string, unknown>,
-  TData extends BaseRecord = TQueryFnData
-> extends UseFormResult<TQueryFnData, TError, TVariables, TData> {
+export interface UseStepsFormReturn<
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
+> extends UseFormReturn<TVariables, TData> {
   currentStep: number;
   gotoStep: (step: number) => void;
   next: () => void;
@@ -31,23 +28,22 @@ export interface UseStepsFormResult<
  * Extends `useForm` with step navigation state (currentStep, next, prev, gotoStep).
  */
 export function useStepsForm<
-  TQueryFnData extends BaseRecord = BaseRecord,
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
   TError = HttpError,
-  TVariables = Record<string, unknown>,
-  TData extends BaseRecord = TQueryFnData
->(options: UseStepsFormOptions<TQueryFnData, TError, TVariables, TData> = {} as UseStepsFormOptions<TQueryFnData, TError, TVariables, TData>): UseStepsFormResult<TQueryFnData, TError, TVariables, TData> {
-  const form = useForm<TQueryFnData, TError, TVariables, TData>(options);
-  
+>(options: UseStepsFormOptions<TVariables, TData, TError> = {} as UseStepsFormOptions<TVariables, TData, TError>): UseStepsFormReturn<TVariables, TData> {
+  const form = useForm<TVariables, TData, TError>(options);
+
   let currentStep = $state(options.defaultStep ?? 0);
-  
+
   function gotoStep(step: number) {
     currentStep = Math.max(0, step);
   }
-  
+
   function next() {
     gotoStep(currentStep + 1);
   }
-  
+
   function prev() {
     if (currentStep > 0) {
       gotoStep(currentStep - 1);
@@ -55,14 +51,14 @@ export function useStepsForm<
   }
 
   // Inject stepping features into the returned useForm object while preserving its reactive getters.
-  const result = form as unknown as UseStepsFormResult<TQueryFnData, TError, TVariables, TData>;
-  
+  const result = form as unknown as UseStepsFormReturn<TVariables, TData>;
+
   Object.defineProperty(result, 'currentStep', {
     get: () => currentStep,
     enumerable: true,
     configurable: true
   });
-  
+
   result.gotoStep = gotoStep;
   result.next = next;
   result.prev = prev;

package/src/utility-hooks.svelte.ts

@@ -1,8 +1,8 @@
-import { useForm, type UseFormOptions } from './form-hooks.svelte';
+import { useForm, type UseFormOptions, type UseFormReturn } from './form-hooks.svelte';
 import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed.svelte';
 import { getResource, getResources } from './context.svelte';
-import { getAdminOptions } from './options';
+import { getAdminOptions } from './options.svelte';
 import { navigate } from './router';
 import { t } from './i18n.svelte';
 import type { BaseRecord, HttpError, Filter, KnownResources, ResourceDefinition } from './types';
@@ -21,21 +21,24 @@ export function useModal(options?: { defaultVisible?: boolean }) {
 
 // ─── useModalForm ─────────────────────────────────────────────
 
-export interface UseModalFormOptions<TQueryFnData extends BaseRecord = BaseRecord, TError = HttpError, TVariables = Record<string, unknown>, TData extends BaseRecord = TQueryFnData> extends UseFormOptions<TQueryFnData, TError, TVariables, TData> {
+export interface UseModalFormOptions<
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
+  TError = HttpError,
+> extends UseFormOptions<TVariables, TData, TError> {
   defaultVisible?: boolean;
-  autoSave?: UseFormOptions<TQueryFnData, TError, TVariables, TData>['autoSave'] & {
+  autoSave?: UseFormOptions<TVariables, TData, TError>['autoSave'] & {
     invalidateOnClose?: boolean;
   };
 }
 
 export function useModalForm<
-  TQueryFnData extends BaseRecord = BaseRecord,
+  TVariables extends Record<string, unknown> = Record<string, unknown>,
+  TData extends BaseRecord = BaseRecord,
   TError = HttpError,
-  TVariables = Record<string, unknown>,
-  TData extends BaseRecord = TQueryFnData
->(options: UseModalFormOptions<TQueryFnData, TError, TVariables, TData> = {}) {
+>(options: UseModalFormOptions<TVariables, TData, TError> = {} as UseModalFormOptions<TVariables, TData, TError>) {
   const queryClient = useQueryClient();
-  const formState = useForm(options);
+  const formState = useForm<TVariables, TData, TError>(options);
   let visible = $state(options.defaultVisible ?? false);
 
   function show(id?: string | number) {
@@ -45,7 +48,7 @@ export function useModalForm<
 
   function close() {
     visible = false;
-    formState.clearErrors();
+    formState.reset();
     if (options.autoSave?.invalidateOnClose) {
       queryClient.invalidateQueries({ queryKey: [formState.resource] });
     }