@svadmin/core 0.22.0 → 0.23.0

package/src/options.svelte.ts

@@ -54,33 +54,56 @@ const defaultTextTransformers: TextTransformers = {
   singular: (text: string) => text.endsWith('s') ? text.slice(0, -1) : text,
 };
 
-const defaultOptions: AdminOptions = {
-  mutationMode: 'pessimistic',
-  warnWhenUnsavedChanges: false,
-  syncWithLocation: false,
-  liveMode: 'auto',
-  disableServerSideValidation: false,
-  undoableTimeout: 5000,
-  textTransformers: defaultTextTransformers,
-  redirect: { afterCreate: 'list', afterEdit: 'list', afterClone: 'list' },
-  breadcrumb: 'default',
-  disableRouteChangeHandler: false,
-};
+function createDefaultOptions(): AdminOptions {
+  return {
+    mutationMode: 'pessimistic',
+    warnWhenUnsavedChanges: false,
+    syncWithLocation: false,
+    liveMode: 'auto',
+    disableServerSideValidation: false,
+    undoableTimeout: 5000,
+    textTransformers: defaultTextTransformers,
+    redirect: { afterCreate: 'list', afterEdit: 'list', afterClone: 'list' },
+    breadcrumb: 'default',
+    disableRouteChangeHandler: false,
+  };
+}
 
-let adminOptions = $state<AdminOptions>(defaultOptions);
+let adminOptions = $state<AdminOptions>(createDefaultOptions());
 
-export function setAdminOptions(options: AdminOptions): void {
-  adminOptions = {
-    ...defaultOptions,
-    ...options,
-    textTransformers: { ...defaultTextTransformers, ...options.textTransformers },
-  };
+export function setAdminOptions(options: AdminOptions, merge?: boolean): void {
+  if (merge) {
+    adminOptions = {
+      ...adminOptions,
+      ...options,
+      textTransformers: { ...adminOptions.textTransformers, ...options.textTransformers },
+      redirect: { ...adminOptions.redirect, ...options.redirect },
+      reactQuery: { ...adminOptions.reactQuery, ...options.reactQuery },
+      title: { ...adminOptions.title, ...options.title },
+      overtime: { ...adminOptions.overtime, ...options.overtime },
+    };
+  } else {
+    const defaults = createDefaultOptions();
+    adminOptions = {
+      ...defaults,
+      ...options,
+      textTransformers: { ...defaultTextTransformers, ...options.textTransformers },
+      redirect: { ...defaults.redirect, ...options.redirect },
+      reactQuery: { ...defaults.reactQuery, ...options.reactQuery },
+      title: { ...defaults.title, ...options.title },
+      overtime: { ...defaults.overtime, ...options.overtime },
+    };
+  }
 }
 
 export function getAdminOptions(): AdminOptions {
   return adminOptions;
 }
 
+export function resetAdminOptions(): void {
+  adminOptions = createDefaultOptions();
+}
+
 /** Get the resolved text transformers (always returns full set) */
 export function getTextTransformers(): TextTransformers {
   const opts = getAdminOptions();

package/src/permissions.ts

@@ -67,6 +67,10 @@ export function getAccessControlProvider(): AccessControlProvider | null {
   return provider;
 }
 
+export function resetAccessControlProvider(): void {
+  provider = null;
+}
+
 /** Get global button options from the AccessControlProvider */
 export function getAccessControlOptions() {
   return provider?.options ?? {};

package/src/query-hooks.svelte.ts

@@ -3,6 +3,7 @@ import { getAdminOptions } from './options.svelte';
 import { getDataProviderForResource, getDataProvider, getLiveProvider } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
 import {
+  checkError,
   createOvertimeTracker,
   createLiveSubscription,
   fireSuccessNotification,
@@ -22,25 +23,26 @@ import type { LiveMode, LiveEvent } from './live.svelte';
  */
 function extendQuery<Q extends object, E extends Record<string, unknown>>(
   query: Q,
-  extensions: () => E,
+  extensions: E,
 ): Q & E {
   return new Proxy(query, {
     get(target, prop) {
-      if (typeof prop === 'string') {
-        const ext = extensions();
-        if (prop in ext) return ext[prop as keyof E];
+      if (typeof prop === 'string' && prop in extensions) {
+        return extensions[prop as keyof E];
       }
-      return target[prop as keyof Q];
+      return Reflect.get(target, prop);
     },
     has(target, prop) {
-      if (typeof prop === 'string' && prop in extensions()) return true;
-      return prop in target;
+      if (typeof prop === 'string' && prop in extensions) return true;
+      return Reflect.has(target, prop);
     },
   }) as Q & E;
 }
 
 // ─── useList ───────────────────────────────────────────────────
 
+export type MaybeGetter<T> = T | (() => T);
+
 export interface UseListOptions<TData extends BaseRecord = BaseRecord, TError = HttpError> {
   resource?: KnownResources;
   pagination?: Pagination;
@@ -57,55 +59,68 @@ export interface UseListOptions<TData extends BaseRecord = BaseRecord, TError =
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useList<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseListOptions<TData, TError> = {}) {
+export function useList<TData extends BaseRecord = BaseRecord, TError = HttpError>(optionsOrGetter: MaybeGetter<UseListOptions<TData, TError>> = {}) {
   const parsed = useParsed();
-  const resource = options.resource ?? parsed.resource ?? '';
   const adminOptions = getAdminOptions();
-  const provider = getDataProviderForResource(resource, options.dataProviderName);
-
-  const queryOptions = options.queryOptions;
+  
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+  const getResource = () => getOptions().resource ?? parsed.resource ?? '';
 
-  const query = createQuery<GetListResult<TData>, TError>(() => ({
-    queryKey: [resource, 'list', options.pagination, options.sorters, options.filters, options.meta],
-    queryFn: async () => {
-      const result = await provider.getList<TData>({
+  const query = createQuery<GetListResult<TData>, TError>(() => {
+    const opts = getOptions();
+    const resource = getResource();
+    const provider = getDataProviderForResource(resource, opts.dataProviderName);
+    const queryOptions = opts.queryOptions;
+    
+    return {
+      queryKey: [opts.dataProviderName, resource, 'list', opts.pagination, opts.sorters, opts.filters, opts.meta],
+      queryFn: async () => provider.getList<TData>({
         resource,
-        pagination: options.pagination,
-        sorters: options.sorters,
-        filters: options.filters,
-        meta: options.meta,
-      });
-      return result;
-    },
-    enabled: queryOptions?.enabled ?? true,
-    staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-    gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
-    refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
-  }));
+        pagination: opts.pagination,
+        sorters: opts.sorters,
+        filters: opts.filters,
+        meta: opts.meta,
+      }),
+      enabled: queryOptions?.enabled ?? true,
+      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
+      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
+      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
+    };
+  });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => query.isLoading, typeof optionsOrGetter === 'function' ? optionsOrGetter().overtimeOptions : optionsOrGetter.overtimeOptions ?? adminOptions.overtime);
 
-  createLiveSubscription((): LiveSubscriptionParams => ({
-    resource,
-    liveProvider: getLiveProvider(),
-    liveMode: options.liveMode ?? adminOptions.liveMode,
-    onLiveEvent: (e: LiveEvent) => {
-      options.onLiveEvent?.(e);
-      adminOptions.onLiveEvent?.(e);
-    },
-    liveParams: options.liveParams,
-    enabled: queryOptions?.enabled ?? true,
-  }));
+  createLiveSubscription((): LiveSubscriptionParams => {
+    const opts = getOptions();
+    return {
+      resource: getResource(),
+      liveProvider: getLiveProvider(),
+      liveMode: opts.liveMode ?? adminOptions.liveMode,
+      onLiveEvent: (e: LiveEvent) => {
+        opts.onLiveEvent?.(e);
+        adminOptions.onLiveEvent?.(e);
+      },
+      liveParams: opts.liveParams,
+      enabled: opts.queryOptions?.enabled ?? true,
+    };
+  });
 
+  // Track last notification timestamps to prevent duplicate firings on re-render
+  let lastSuccessAt = 0;
+  let lastErrorAt = 0;
   $effect(() => {
-    if (query.isSuccess && options.successNotification) {
-      fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
-    } else if (query.isError) {
-      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+    const opts = getOptions();
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && opts.successNotification) {
+      lastSuccessAt = query.dataUpdatedAt;
+      fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
+      lastErrorAt = query.errorUpdatedAt;
+      checkError(query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
     }
   });
 
-  return extendQuery(query, () => ({ overtime }));
+  return extendQuery(query, { overtime });
 }
 
 // ─── useOne ────────────────────────────────────────────────────
@@ -124,59 +139,95 @@ export interface UseOneOptions<TData extends BaseRecord = BaseRecord, TError = H
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseOneOptions<TData, TError> = {}) {
+export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError>(optionsOrGetter: MaybeGetter<UseOneOptions<TData, TError>> = {}) {
   const parsed = useParsed();
-  const resource = options.resource ?? parsed.resource ?? '';
-  const id = options.id ?? parsed.id;
   const adminOptions = getAdminOptions();
-  const provider = getDataProviderForResource(resource, options.dataProviderName);
+  
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+  const getResource = () => getOptions().resource ?? parsed.resource ?? '';
+  const getId = () => getOptions().id ?? parsed.id;
 
-  const queryOptions = options.queryOptions;
+  const query = createQuery<GetOneResult<TData>, TError>(() => {
+    const opts = getOptions();
+    const resource = getResource();
+    const id = getId();
+    const provider = getDataProviderForResource(resource, opts.dataProviderName);
+    const queryOptions = opts.queryOptions;
 
-  const query = createQuery<GetOneResult<TData>, TError>(() => ({
-    queryKey: [resource, 'one', id, options.meta],
-    queryFn: async () => {
-      if (id == null) throw new Error('useOne requires an id');
-      const result = await provider.getOne<TData>({
-        resource,
-        id,
-        meta: options.meta,
-      });
-      return result;
-    },
-    enabled: (queryOptions?.enabled ?? true) && id != null,
-    staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-    gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
-  }));
+    return {
+      queryKey: [opts.dataProviderName, resource, 'one', id, opts.meta],
+      queryFn: async () => {
+        if (id == null) throw new Error('useOne requires an id');
+        const result = await provider.getOne<TData>({
+          resource,
+          id,
+          meta: opts.meta,
+        });
+        return result;
+      },
+      enabled: (queryOptions?.enabled ?? true) && id != null,
+      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
+      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
+      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
+    };
+  });
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => query.isLoading, typeof optionsOrGetter === 'function' ? optionsOrGetter().overtimeOptions : optionsOrGetter.overtimeOptions ?? adminOptions.overtime);
 
+  createLiveSubscription((): LiveSubscriptionParams => {
+    const opts = getOptions();
+    const resource = getResource();
+    return {
+      resource,
+      liveProvider: getLiveProvider(),
+      liveMode: opts.liveMode ?? adminOptions.liveMode,
+      onLiveEvent: (e: LiveEvent) => {
+        opts.onLiveEvent?.(e);
+        adminOptions.onLiveEvent?.(e);
+      },
+      liveParams: opts.liveParams,
+      enabled: (opts.queryOptions?.enabled ?? true) && getId() != null,
+    };
+  });
+
+  let lastSuccessAt = 0;
+  let lastErrorAt = 0;
   $effect(() => {
-    if (query.isSuccess && options.successNotification) {
-      fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
-    } else if (query.isError) {
-      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+    const opts = getOptions();
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && opts.successNotification) {
+      lastSuccessAt = query.dataUpdatedAt;
+      fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
+      lastErrorAt = query.errorUpdatedAt;
+      checkError(query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
     }
   });
 
-  return extendQuery(query, () => ({ overtime }));
+  return extendQuery(query, { overtime });
 }
 
 // ─── useShow ──────────────────────────────────────────────────
 export function useShow<TData extends BaseRecord = BaseRecord, TError = HttpError>(
-  options: UseOneOptions<TData, TError> = {}
+  optionsOrGetter: MaybeGetter<UseOneOptions<TData, TError>> = {}
 ) {
   const parsed = useParsed();
-  let showId = $state<string | number | undefined>(options.id ?? parsed.id);
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
+  
+  let _showId = $state<string | number | undefined>(undefined);
+  
+  // showId prioritizes explicit setShowId, then options.id, then URL id.
+  const showId = $derived(_showId ?? getOptions().id ?? parsed.id);
 
-  function setShowId(id: string | number) { showId = id; }
+  function setShowId(id: string | number) { _showId = id; }
 
-  const result = useOne<TData, TError>({
-    ...options,
-    get id() { return showId; },
-  });
+  // We wrap it in a getter so useOne evaluates it dynamically.
+  const result = useOne<TData, TError>(() => ({
+    ...getOptions(),
+    id: showId,
+  }));
 
-  return extendQuery(result, () => ({ showId, setShowId }));
+  return extendQuery(result, { get showId() { return showId; }, setShowId });
 }
 
 // ─── useMany ───────────────────────────────────────────────────
@@ -195,33 +246,64 @@ export interface UseManyOptions<TData extends BaseRecord = BaseRecord, TError =
   overtimeOptions?: OvertimeOptions;
 }
 
-export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseManyOptions<TData, TError>) {
-  const { resource, ids, meta, dataProviderName, queryOptions } = options;
+export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpError>(optionsOrGetter: MaybeGetter<UseManyOptions<TData, TError>>) {
   const adminOptions = getAdminOptions();
-  const provider = getDataProviderForResource(resource, dataProviderName);
-
-  const query = createQuery<GetManyResult<TData>, TError>(() => ({
-    queryKey: [resource, 'many', ids, meta],
-    queryFn: async () => {
-      if (!ids.length) return { data: [] };
-      if (provider.getMany) {
-        return provider.getMany<TData>({ resource, ids, meta });
-      }
-      const results = await Promise.all(ids.map(id => provider.getOne<TData>({ resource, id, meta })));
-      return { data: results.map(r => r.data) };
-    },
-    enabled: (queryOptions?.enabled ?? true) && ids.length > 0,
-    staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
-  }));
+  const getOptions = () => typeof optionsOrGetter === 'function' ? optionsOrGetter() : optionsOrGetter;
 
-  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
+  const query = createQuery<GetManyResult<TData>, TError>(() => {
+    const opts = getOptions();
+    const { resource, ids, meta, dataProviderName, queryOptions } = opts;
+    const provider = getDataProviderForResource(resource, dataProviderName);
 
+    return {
+      queryKey: [dataProviderName, resource, 'many', ids, meta],
+      queryFn: async () => {
+        if (!ids.length) return { data: [] };
+        if (provider.getMany) {
+          return provider.getMany<TData>({ resource, ids, meta });
+        }
+        const results = await Promise.all(ids.map(id => provider.getOne<TData>({ resource, id, meta })));
+        return { data: results.map(r => r.data) };
+      },
+      enabled: (queryOptions?.enabled ?? true) && ids.length > 0,
+      staleTime: queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
+      gcTime: queryOptions?.gcTime ?? adminOptions.reactQuery?.gcTime,
+      refetchOnWindowFocus: queryOptions?.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
+    };
+  });
+
+  const overtime = createOvertimeTracker(() => query.isLoading, typeof optionsOrGetter === 'function' ? optionsOrGetter().overtimeOptions : optionsOrGetter.overtimeOptions ?? adminOptions.overtime);
+
+  createLiveSubscription((): LiveSubscriptionParams => {
+    const opts = getOptions();
+    return {
+      resource: opts.resource,
+      liveProvider: getLiveProvider(),
+      liveMode: opts.liveMode ?? adminOptions.liveMode,
+      onLiveEvent: (e: LiveEvent) => {
+        opts.onLiveEvent?.(e);
+        adminOptions.onLiveEvent?.(e);
+      },
+      liveParams: opts.liveParams,
+      enabled: (opts.queryOptions?.enabled ?? true) && opts.ids.length > 0,
+    };
+  });
+
+  let lastSuccessAt = 0;
+  let lastErrorAt = 0;
   $effect(() => {
-    if (query.isSuccess && options.successNotification) fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
-    else if (query.isError) fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+    const opts = getOptions();
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && opts.successNotification) {
+      lastSuccessAt = query.dataUpdatedAt;
+      fireSuccessNotification(opts.successNotification, '', query.data, undefined, opts.resource);
+    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
+      lastErrorAt = query.errorUpdatedAt;
+      checkError(query.error);
+      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error);
+    }
   });
 
-  return extendQuery(query, () => ({ overtime }));
+  return extendQuery(query, { overtime });
 }
 
 export function useApiUrl(dataProviderName?: string): string {

package/src/router-provider.ts

@@ -100,7 +100,9 @@ export function createHistoryRouterProvider(basePath = ''): RouterProvider {
       if (typeof window === 'undefined') {
         return { resource: undefined, action: undefined, id: undefined, params: {}, pathname: '/' };
       }
-      const pathname = window.location.pathname.replace(basePath, '') || '/';
+      const pathname = (basePath && window.location.pathname.startsWith(basePath)
+        ? window.location.pathname.slice(basePath.length) || '/'
+        : window.location.pathname);
       const params: Record<string, string> = {};
       for (const [k, v] of new URLSearchParams(window.location.search).entries()) {
         params[k] = v;

package/src/router.ts

@@ -7,13 +7,26 @@ interface RouteMatch {
   params: Record<string, string>;
 }
 
-// Store a reference to the active RouterProvider (set by router-state.svelte.ts)
+export type RouteGuard = (to: string, from: string) => boolean | Promise<boolean>;
+
 let _routerProvider: RouterProvider | undefined;
+let _beforeGuards: RouteGuard[] = [];
+let _afterGuards: ((to: string, from: string) => void)[] = [];
 
 export function setActiveRouterProvider(provider: RouterProvider | undefined) {
   _routerProvider = provider;
 }
 
+export function beforeEach(guard: RouteGuard): () => void {
+  _beforeGuards.push(guard);
+  return () => { _beforeGuards = _beforeGuards.filter(g => g !== guard); };
+}
+
+export function afterEach(guard: (to: string, from: string) => void): () => void {
+  _afterGuards.push(guard);
+  return () => { _afterGuards = _afterGuards.filter(g => g !== guard); };
+}
+
 // Parse route pattern like /products/edit/:id into regex
 function compileRoute(pattern: string): { regex: RegExp; keys: string[] } {
   const keys: string[] = [];
@@ -50,12 +63,20 @@ export function matchRoute(
   return null;
 }
 
-export function navigate(path: string, options?: { replaceState?: boolean }): void {
+export async function navigate(path: string, options?: { replaceState?: boolean }): Promise<void> {
+  const from = currentPath();
+  for (const guard of _beforeGuards) {
+    const allowed = await guard(path, from);
+    if (!allowed) return;
+  }
   if (_routerProvider) {
     _routerProvider.go({ to: path, type: options?.replaceState ? 'replace' : 'push' });
   } else if (typeof window !== 'undefined') {
     window.location.hash = '#' + path.replace(/^#/, '');
   }
+  for (const guard of _afterGuards) {
+    guard(path, from);
+  }
 }
 
 /**

package/src/routing-hooks.svelte.ts

@@ -6,11 +6,24 @@ import { useParsed } from './useParsed.svelte';
 
 export function useGetToPath() {
   const routerProvider = getRouterProvider();
+  const parsed = useParsed();
 
   return (options: { resource?: string; action?: 'list' | 'create' | 'edit' | 'show' | 'clone'; id?: string | number; meta?: Record<string, unknown> }) => {
-    const { resource, action, id } = options;
+    const { resource, action, id, meta } = options;
     if (!resource) return '/';
-    let path = `/${resource}`;
+
+    // Support nested resources: use meta.parentPath or auto-detect from current URL
+    let basePath: string;
+    if (meta?.parentPath) {
+      basePath = `${meta.parentPath}/${resource}`;
+    } else if (parsed.resourcePath && parsed.resource === resource) {
+      // Re-use the current nested path context (e.g., /teams/123/users)
+      basePath = `/${parsed.resourcePath}`;
+    } else {
+      basePath = `/${resource}`;
+    }
+
+    let path = basePath;
     if (action === 'create') path += '/create';
     else if (action === 'edit' && id) path += `/edit/${id}`;
     else if (action === 'show' && id) path += `/show/${id}`;
@@ -70,16 +83,28 @@ export function useLink() {
 
 export function useResource(resourceName?: string) {
   const parsed = useParsed();
-  const targetResource = resourceName ?? parsed.resource;
-  if (!targetResource) {
-    return { resource: undefined, resources: getResources() };
-  }
-  try {
-    const resource = getResource(targetResource);
-    return { resource, resources: getResources() };
-  } catch {
-    return { resource: undefined, resources: getResources() };
-  }
+
+  // Derived resource — re-evaluates when parsed.resource or resourceName changes
+  const resolvedResource = $derived.by(() => {
+    const target = resourceName ?? parsed.resource;
+    if (!target) return undefined;
+    try {
+      return getResource(target);
+    } catch {
+      return undefined;
+    }
+  });
+
+  return {
+    get resource() { return resolvedResource; },
+    get resources() { return getResources(); },
+    get identifier() { return resolvedResource?.identifier ?? resolvedResource?.name; },
+    /** Resolve a resource by name — useful for dynamic lookups inside callbacks */
+    select: (name: string) => {
+      const res = getResource(name);
+      return { resource: res, identifier: res.identifier ?? res.name };
+    },
+  };
 }
 
 export function useNavigation() {
@@ -87,11 +112,11 @@ export function useNavigation() {
   const parsed = useParsed();
 
   return {
-    create: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'create' }),
-    edit: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'edit', id: id ?? parsed.id }),
-    clone: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'clone', id: id ?? parsed.id }),
-    show: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'show', id: id ?? parsed.id }),
-    list: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resource, action: 'list' }),
+    create: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'create' }),
+    edit: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'edit', id: id ?? parsed.id }),
+    clone: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'clone', id: id ?? parsed.id }),
+    show: (resource?: string, id?: string | number) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'show', id: id ?? parsed.id }),
+    list: (resource?: string) => go({ type: 'push', resource: resource ?? parsed.resourcePath ?? parsed.resource, action: 'list' }),
     push: (url: string) => go({ to: url, type: 'push' }),
     replace: (url: string) => go({ to: url, type: 'replace' }),
     goBack: useBack(),