rimecms 0.28.9 → 0.29.0

package/dist/core/dev/generate/routes/common.server.js

@@ -9,7 +9,7 @@ const DOLLAR_LIB = '$lib';
  */
 const mainLayout = () => `
 import type { ServerLoadEvent } from '@sveltejs/kit';
-export const load = async ({ locals, url }: ServerLoadEvent) => {
+export const load = async ({ locals }: ServerLoadEvent) => {
 	return { user: locals.user };
 };`;
 /**
@@ -50,8 +50,8 @@ const error = () => `
 const rootLayout = () => `
 <script lang="ts">
 	import type { Snippet } from 'svelte';
-	import type { Dictionaries } from '${PACKAGE_NAME}/i18n';
-	import i18n from '${PACKAGE_NAME}/i18n';
+	import type { Dictionaries } from '${PACKAGE_NAME}';
+	import { i18n } from '${PACKAGE_NAME}';
 	import '${PACKAGE_NAME}/panel/style/index.css';
 
 	type Props = { children: Snippet; data: { translations: Dictionaries } };
@@ -71,7 +71,7 @@ const rootLayout = () => `
  */
 const rootLayoutServer = () => `
 import type { ServerLoadEvent } from '@sveltejs/kit';
-import { registerTranslation } from '${PACKAGE_NAME}/i18n/register.server.js';
+import { registerTranslation } from '${PACKAGE_NAME}/server';
 
 export const ssr = false;
 
@@ -85,8 +85,8 @@ export const load = async ({ locals }: ServerLoadEvent) => {
  * (rime)/panel/sign-in/+page.svelte
  */
 const signInPage = () => `
-<script lang="ts">
-  import { SignIn } from '${PACKAGE_NAME}/panel/auth/client';
+<script>
+  import { SignIn } from '${PACKAGE_NAME}/panel';
   const { data } = $props();
 </script>
 
@@ -96,10 +96,12 @@ const signInPage = () => `
  * (rime)/auth/sign-in/+page@(rime).server.ts
  */
 const signInPageServer = () => `
-import { authLoads, authActions } from '${PACKAGE_NAME}/panel/auth';
+import { type ServerLoadEvent, type RequestEvent } from '@sveltejs/kit';
 
-export const load = authLoads.signIn;
-export const actions = authActions.signIn;
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.signIn(event);
+export const actions = {
+  default: (event: RequestEvent) => event.locals.routes.panel.actions.signIn(event)
+};
 `;
 /**
  * Forgot password page template
@@ -107,7 +109,7 @@ export const actions = authActions.signIn;
  */
 const forgotPasswordPage = () => `
 <script>
-  import { ForgotPassword } from '${PACKAGE_NAME}/panel/auth/client'
+  import { ForgotPassword } from '${PACKAGE_NAME}/panel'
   const { data } = $props();
 </script>
 <ForgotPassword {data} />`;
@@ -116,17 +118,17 @@ const forgotPasswordPage = () => `
  * (rime)/forgot-password/+page.server.ts
  */
 const forgotPasswordPageServer = () => `
-import { authLoads } from '${PACKAGE_NAME}/panel/auth';
+import { type ServerLoadEvent } from '@sveltejs/kit';
 
-export const load = authLoads.forgotPassword;
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.forgotPassword(event);
 `;
 /**
  * Reset password page template
  * (rime)/reset-password/+page.svelte
  */
 const resetPasswordPage = () => `
-<script lang="ts">
-  import { ResetPassword } from '${PACKAGE_NAME}/panel/auth/client';
+<script>
+  import { ResetPassword } from '${PACKAGE_NAME}/panel';
   const { data } = $props();
 </script>
 
@@ -136,9 +138,9 @@ const resetPasswordPage = () => `
  * (rime)/reset-password/+page.server.ts
  */
 const resetPasswordPageServer = () => `
-import { authLoads } from '${PACKAGE_NAME}/panel/auth';
+import { type ServerLoadEvent } from '@sveltejs/kit';
 
-export const load = authLoads.resetPassword;
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.resetPassword(event);
 `;
 /**
  * Panel layout template
@@ -146,7 +148,7 @@ export const load = authLoads.resetPassword;
  */
 const panelLayout = () => `
 <script>
-	import { Panel } from '${PACKAGE_NAME}/panel/client';
+  import { Panel } from '${PACKAGE_NAME}/panel';
 	import config from '${DOLLAR_LIB}/${OUTPUT_DIR}/rime.config.js';
 	
 	const { children, data } = $props();
@@ -168,8 +170,8 @@ const panelLayoutServer = () => `
 import { type ServerLoadEvent } from '@sveltejs/kit';
 
 export const load = async ({ locals }: ServerLoadEvent) => {
-  const { user, locale, routes } = locals;
-  return { user, locale, routes };
+  const { user, locale, navigation } = locals;
+  return { user, locale, routes: navigation };
 };`;
 /**
  * Panel page template
@@ -177,7 +179,7 @@ export const load = async ({ locals }: ServerLoadEvent) => {
  */
 const panelPage = () => `
 <script>
-  import { Dashboard } from '${PACKAGE_NAME}/panel/client';
+  import { Dashboard } from '${PACKAGE_NAME}/panel';
   const { data } = $props();
 </script>
 
@@ -187,18 +189,17 @@ const panelPage = () => `
  * (rime)/panel/+page.server.ts
  */
 const panelPageServer = () => `
-import { pagesLoad } from '${PACKAGE_NAME}/panel';
+import { type ServerLoadEvent } from '@sveltejs/kit';
 
-export const load = pagesLoad.dashboard;`;
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.dashboard(event);`;
 /**
  * Live page template
  * (rime)/live/+page.svelte
  */
 const livePage = () => `
-<script lang="ts">
-  import { Live } from '${PACKAGE_NAME}/panel/client';
-
-  import config from '../../../../lib/${OUTPUT_DIR}/rime.config.js';
+<script>
+  import { Live } from '${PACKAGE_NAME}/panel';
+  import config from '${DOLLAR_LIB}/${OUTPUT_DIR}/rime.config.js';
 
   const { data } = $props();
 </script>
@@ -210,9 +211,192 @@ const livePage = () => `
  * (rime)/live/+page.server.ts
  */
 const livePageServer = () => `
-import { pagesLoad } from '${PACKAGE_NAME}/panel';
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.live(event);`;
+/****************************************************/
+/* Panel /[slug=collection|area]/... and API /api/[slug=collection|area]/...
+/* — fixed, generic, matcher-disambiguated routes shared by every
+/* collection/area, generated once regardless of how many are configured.
+/* The [slug=collection]/[slug=area] param matchers (src/params/, see
+/* collectionMatcher/areaMatcher below) route each slug to the right folder
+/* at the SvelteKit router level, so collection and area pages/endpoints are
+/* genuinely separate routes — no runtime kind-branching inside a shared
+/* component, no unauthenticated-branch union fighting the component's data
+/* prop type. Each reads slug/id off event.params (a real dynamic route
+/* param) via event.locals.routes, so none of these import anything from
+/* rimecms besides the panel components.
+/****************************************************/
+/**
+ * Collection list page
+ * (rime)/panel/[slug=collection]/+page.svelte
+ */
+const collectionListPage = () => `
+<script>
+  import { Collection } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<Collection {data} slug={data.slug} />`;
+/**
+ * (rime)/panel/[slug=collection]/+page.server.ts
+ */
+const collectionListPageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = async (event: ServerLoadEvent) => {
+  const data = await event.locals.routes.panel.load.collection(event);
+  return { ...data, slug: event.params.slug || '' };
+};`;
+/**
+ * Area document page
+ * (rime)/panel/[slug=area]/+page.svelte
+ */
+const areaDocPage = () => `
+<script>
+  import { Area } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<Area {data} />`;
+/**
+ * (rime)/panel/[slug=area]/+page.server.ts
+ */
+const areaDocPageServer = () => `
+import type { RequestEvent, ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.area(event);
+
+export const actions = {
+  update: (event: RequestEvent) => event.locals.routes.panel.actions.area.update(event)
+};`;
+/**
+ * Collection document page
+ * (rime)/panel/[slug=collection]/[id]/+page.svelte
+ */
+const collectionDocPage = () => `
+<script>
+  import { CollectionDoc } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<CollectionDoc {data} />`;
+/**
+ * (rime)/panel/[slug=collection]/[id]/+page.server.ts
+ */
+const collectionDocPageServer = () => `
+import type { RequestEvent, ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.document(event);
+
+export const actions = {
+  create: (event: RequestEvent) => event.locals.routes.panel.actions.document.create(event),
+  update: (event: RequestEvent) => event.locals.routes.panel.actions.document.update(event)
+};`;
+/**
+ * Collection document versions page
+ * (rime)/panel/[slug=collection]/[id]/versions/+page.svelte
+ */
+const collectionDocVersionsPage = () => `
+<script>
+  import { CollectionDocVersions } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<CollectionDocVersions data={data} />`;
+/**
+ * (rime)/panel/[slug=collection]/[id]/versions/+page.server.ts
+ */
+const collectionDocVersionsPageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) =>
+  event.locals.routes.panel.load.documentVersions(event);`;
+/**
+ * Area document versions page
+ * (rime)/panel/[slug=area]/versions/+page.svelte
+ */
+const areaVersionsPage = () => `
+<script>
+  import { AreaVersionsDoc } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<AreaVersionsDoc data={data} />`;
+/**
+ * (rime)/panel/[slug=area]/versions/+page.server.ts
+ */
+const areaVersionsPageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.areaVersions(event);`;
+/**
+ * Collection REST endpoint (list-level)
+ * (rime)/api/[slug=collection]/+server.ts
+ */
+const collectionApiServer = () => `
+import { type RequestEvent } from '@sveltejs/kit';
+
+export const GET = (event: RequestEvent) => event.locals.routes.rest.collection.get(event);
+export const POST = (event: RequestEvent) => event.locals.routes.rest.collection.create(event);
+export const DELETE = (event: RequestEvent) => event.locals.routes.rest.collection.delete(event);`;
+/**
+ * Area REST endpoint — singleton, no [id] tier: GET reads it, PATCH updates
+ * it, no create/delete (areas are config-defined, not created/removed via API).
+ * (rime)/api/[slug=area]/+server.ts
+ */
+const areaApiServer = () => `
+import { type RequestEvent } from '@sveltejs/kit';
 
-export const load = pagesLoad.live;`;
+export const GET = (event: RequestEvent) => event.locals.routes.rest.area.get(event);
+export const PATCH = (event: RequestEvent) => event.locals.routes.rest.area.update(event);`;
+/**
+ * Collection REST endpoint (id-level)
+ * (rime)/api/[slug=collection]/[id]/+server.ts
+ */
+const collectionIdApiServer = () => `
+import { type RequestEvent } from '@sveltejs/kit';
+
+export const GET = (event: RequestEvent) => event.locals.routes.rest.collection.getById(event);
+export const PATCH = (event: RequestEvent) => event.locals.routes.rest.collection.updateById(event);
+export const DELETE = (event: RequestEvent) => event.locals.routes.rest.collection.deleteById(event);`;
+/**
+ * Collection duplicate action
+ * (rime)/api/[slug=collection]/[id]/duplicate/+server.ts
+ */
+const collectionDuplicateApiServer = () => `
+import { type RequestEvent } from '@sveltejs/kit';
+
+export const POST = (event: RequestEvent) => event.locals.routes.rest.collection.duplicate(event);`;
+/**
+ * Param matchers backing [slug=collection]/[slug=area] — bake in the actual
+ * configured slug list at generation time so they stay isomorphic (no
+ * server-only config import; SvelteKit resolves matchers on the client too
+ * for client-side navigation), same approach as this repo's own hand-written
+ * src/params/news.ts, lang.ts.
+ * src/params/collection.ts, src/params/area.ts
+ */
+const paramMatcher = (slugs) => `
+import type { ParamMatcher } from '@sveltejs/kit';
+
+const slugs = ${JSON.stringify(slugs)} as const;
+
+export const match: ParamMatcher = (param): param is (typeof slugs)[number] =>
+  (slugs as readonly string[]).includes(param);`;
+/**
+ * Catch-all so /api/* stays a literal, static-prefixed SvelteKit route —
+ * without it, an unmatched /api/* request (unknown slug, wrong shape) would
+ * fall through to the next candidate in the manifest, e.g. the public site's
+ * (front)/[[locale]]/[[id]] route, silently binding garbage params instead
+ * of 404ing.
+ * (rime)/api/[...rest]/+server.ts
+ */
+const apiCatchAllServer = () => `
+import { error } from '@sveltejs/kit';
+
+export const fallback = async () => {
+  throw error(404);
+};`;
 /**
  * Custom route template generator
  * Used for generating custom routes
@@ -276,6 +460,41 @@ export const commonRoutes = {
     '(rime)/panel/live-edit': {
         'page@(rime)': livePage,
         pageServer: livePageServer
+    },
+    '(rime)/panel/[slug=collection]': {
+        page: collectionListPage,
+        pageServer: collectionListPageServer
+    },
+    '(rime)/panel/[slug=collection]/[id]': {
+        page: collectionDocPage,
+        pageServer: collectionDocPageServer
+    },
+    '(rime)/panel/[slug=collection]/[id]/versions': {
+        page: collectionDocVersionsPage,
+        pageServer: collectionDocVersionsPageServer
+    },
+    '(rime)/panel/[slug=area]': {
+        page: areaDocPage,
+        pageServer: areaDocPageServer
+    },
+    '(rime)/panel/[slug=area]/versions': {
+        page: areaVersionsPage,
+        pageServer: areaVersionsPageServer
+    },
+    '(rime)/api/[slug=collection]': {
+        server: collectionApiServer
+    },
+    '(rime)/api/[slug=collection]/[id]': {
+        server: collectionIdApiServer
+    },
+    '(rime)/api/[slug=collection]/[id]/duplicate': {
+        server: collectionDuplicateApiServer
+    },
+    '(rime)/api/[slug=area]': {
+        server: areaApiServer
+    },
+    '(rime)/api/[...rest]': {
+        server: apiCatchAllServer
     }
 };
-export { customRoute };
+export { customRoute, paramMatcher };

package/dist/core/dev/generate/routes/index.server.d.ts

@@ -1,6 +1,12 @@
 import type { Config } from '../../../../types.js';
 /**
- * Main function to generate browser routes based on configuration
+ * Main function to generate browser routes based on configuration.
+ * commonRoutes is a fixed set of files (layout, sign-in, dashboard, the
+ * matcher-disambiguated /panel/[slug=collection|area]/... and
+ * /api/[slug=collection|area]/... dynamic routes) — it no longer varies with
+ * how many collections/areas are configured, so there's no per-collection/area
+ * loop here anymore. The src/params/collection.ts and area.ts matchers backing
+ * those routes DO bake in the actual slug list, so they're rewritten here too.
  */
 declare function generateRoutes<T extends Config>(config: T): void;
 export default generateRoutes;

package/dist/core/dev/generate/routes/index.server.js

@@ -1,20 +1,21 @@
 import { logger } from '../../../logger/index.server.js';
-import { withDirectoriesSuffix, withVersionsSuffix } from '../../../naming.js';
 import fs from 'fs';
 import path from 'path';
-import { areaAPIRoutes, areaRoutes, areaVersionsPanelRoutes } from './area.server.js';
-import { collectionAPIRoutes, collectionPanelRoutes, collectionVersionsPanelRoutes } from './collection.server.js';
-import { commonRoutes, customRoute } from './common.server.js';
+import { commonRoutes, customRoute, paramMatcher } from './common.server.js';
 import { injectCustomCSS, removeCustomCSS } from './custom-css.server.js';
 import { ensureDir, shouldRegenerateRoutes, writeRouteFile } from './util.server.js';
 const projectRoot = process.cwd();
 /**
- * Main function to generate browser routes based on configuration
+ * Main function to generate browser routes based on configuration.
+ * commonRoutes is a fixed set of files (layout, sign-in, dashboard, the
+ * matcher-disambiguated /panel/[slug=collection|area]/... and
+ * /api/[slug=collection|area]/... dynamic routes) — it no longer varies with
+ * how many collections/areas are configured, so there's no per-collection/area
+ * loop here anymore. The src/params/collection.ts and area.ts matchers backing
+ * those routes DO bake in the actual slug list, so they're rewritten here too.
  */
 function generateRoutes(config) {
     logger.info('Routes generation...');
-    const areas = (config.areas || []).filter((a) => a._generateRoutes !== false);
-    const collections = (config.collections || []).filter((c) => c._generateRoutes !== false);
     // 1. Check if routes need to be regenerated
     if (!shouldRegenerateRoutes(config)) {
         return;
@@ -23,62 +24,22 @@ function generateRoutes(config) {
     const rootRoutes = path.resolve(projectRoot, 'src', 'routes');
     const rimeRoutes = path.join(rootRoutes, '(rime)');
     const panelRoute = path.join(rimeRoutes, 'panel');
+    const paramsDir = path.resolve(projectRoot, 'src', 'params');
     fs.rmSync(rimeRoutes, { recursive: true, force: true });
     ensureDir(rootRoutes);
     ensureDir(rimeRoutes);
     ensureDir(panelRoute);
-    // Function that generate area/collection routes files from a Routes object
-    const processRoutes = (slug, kebab, routes) => {
-        for (const [pattern, files] of Object.entries(routes)) {
-            const routePath = pattern.replace('{area.kebab}', kebab).replace('{collection.kebab}', kebab);
-            // Generate each file type (page, layout, etc.)
-            for (const [fileType, templateFn] of Object.entries(files)) {
-                writeRouteFile(rootRoutes, routePath, fileType, templateFn(slug));
-            }
-        }
-    };
-    // 3. Process common routes
+    ensureDir(paramsDir);
+    // 3. Process common routes (now includes the matcher-disambiguated [slug=collection|area] routes)
     for (const [pattern, files] of Object.entries(commonRoutes)) {
         for (const [fileType, templateFn] of Object.entries(files)) {
             writeRouteFile(rootRoutes, pattern, fileType, templateFn());
         }
     }
-    // 4. Process area routes
-    for (const area of areas) {
-        processRoutes(area.slug, area.kebab, areaRoutes);
-        processRoutes(area.slug, area.kebab, areaAPIRoutes);
-        if (area.versions) {
-            processRoutes(area.slug, area.kebab, areaVersionsPanelRoutes);
-            // Use collections API route as area_versions is a collection
-            processRoutes(withVersionsSuffix(area.slug), withVersionsSuffix(area.kebab), collectionAPIRoutes);
-        }
-    }
-    // 5. Process collection routes
-    for (const collection of collections) {
-        // Function that generate routes files
-        const processRoutes = (slug, kebab, routes) => {
-            for (const [pattern, files] of Object.entries(routes)) {
-                const routePath = pattern.replace('{collection.kebab}', kebab);
-                // Generate each file type (page, layout, etc.)
-                for (const [fileType, templateFn] of Object.entries(files)) {
-                    // Check if function takes parameters before calling it
-                    const content = templateFn.length > 0 ? templateFn(slug) : templateFn();
-                    writeRouteFile(rootRoutes, routePath, fileType, content);
-                }
-            }
-        };
-        // Panel routes
-        processRoutes(collection.slug, collection.kebab, collectionPanelRoutes);
-        processRoutes(collection.slug, collection.kebab, collectionAPIRoutes);
-        if (collection.versions) {
-            processRoutes(collection.slug, collection.kebab, collectionVersionsPanelRoutes);
-            processRoutes(withVersionsSuffix(collection.slug), withVersionsSuffix(collection.kebab), collectionAPIRoutes);
-        }
-        if (collection.upload) {
-            processRoutes(withDirectoriesSuffix(collection.slug), withDirectoriesSuffix(collection.kebab), collectionAPIRoutes);
-        }
-    }
-    // 6. Handle custom routes from config
+    // 4. Write the [slug=collection]/[slug=area] param matchers
+    fs.writeFileSync(path.join(paramsDir, 'collection.ts'), paramMatcher((config.collections || []).map((c) => c.slug)));
+    fs.writeFileSync(path.join(paramsDir, 'area.ts'), paramMatcher((config.areas || []).map((a) => a.slug)));
+    // 5. Handle custom routes from config
     const customRoutes = config.panel?.routes;
     if (customRoutes) {
         for (const [route, routeConfig] of Object.entries(customRoutes)) {
@@ -86,7 +47,7 @@ function generateRoutes(config) {
             writeRouteFile(rootRoutes, routePath, 'page', customRoute(routeConfig));
         }
     }
-    // 7. Handle custom CSS in layout file
+    // 6. Handle custom CSS in layout file
     const layoutPath = path.join(rimeRoutes, '+layout.svelte');
     if (fs.existsSync(layoutPath)) {
         if (config.panel?.css) {

package/dist/core/dev/generate/routes/util.server.d.ts

@@ -6,13 +6,13 @@ export type RouteTemplateFunction<T extends any[] = any[]> = (...args: T) => str
 export type RouteDefinition = Record<string, RouteTemplateFunction>;
 export type Routes = Record<string, RouteDefinition>;
 /**
- * Check if routes need to be regenerated based on config changes
+ * Check if routes need to be regenerated based on config changes.
+ * Panel/API routes are a fixed set of dynamic-segment files (file count never
+ * grows with schema size), but the [slug=collection]/[slug=area] param
+ * matchers under src/params/ bake in the actual slug lists, so adding,
+ * removing, or renaming a collection/area still needs a regen to keep those
+ * matchers in sync — same trigger as custom routes and panel CSS.
  * @returns true if routes should be regenerated, false otherwise
- * @example
- * // Check if routes need to be regenerated
- * const config = { areas: [], collections: [], panel: { css: 'styles.css' } };
- * const needsRegeneration = shouldRegenerateRoutes(config);
- * // If the config has changed since last run, needsRegeneration will be true
  */
 export declare function shouldRegenerateRoutes<T extends Config>(config: T): boolean;
 /**
@@ -40,13 +40,3 @@ export declare function ensureDir(dirPath: string): void;
  * // Creates /path/to/src/routes/(rime)/panel/news/+page.svelte with the provided content
  */
 export declare function writeRouteFile(basePath: string, routePath: string, fileType: string, content: string): void;
-/**
- * Cast slug in generated templates for document with versions
- * in order to prevent TS error that slug_versions is not a collection/area
- *
- * @example
- * castVersionSlug('pages_versions')
- * // output : 'pages_versions' as any
- * export const GET = api.collection.get('pages_versions' as any)
- */
-export declare const TScastVersionSlug: (slug: string) => string;

package/dist/core/dev/generate/routes/util.server.js

@@ -1,29 +1,26 @@
 import cache from '../../cache/index.server.js';
-import { hasDirectoriesSuffix, hasVersionsSuffix } from '../../../naming.js';
 import { slugify } from '../../../../util/string.js';
 import fs from 'fs';
 import path from 'path';
 /**
- * Check if routes need to be regenerated based on config changes
+ * Check if routes need to be regenerated based on config changes.
+ * Panel/API routes are a fixed set of dynamic-segment files (file count never
+ * grows with schema size), but the [slug=collection]/[slug=area] param
+ * matchers under src/params/ bake in the actual slug lists, so adding,
+ * removing, or renaming a collection/area still needs a regen to keep those
+ * matchers in sync — same trigger as custom routes and panel CSS.
  * @returns true if routes should be regenerated, false otherwise
- * @example
- * // Check if routes need to be regenerated
- * const config = { areas: [], collections: [], panel: { css: 'styles.css' } };
- * const needsRegeneration = shouldRegenerateRoutes(config);
- * // If the config has changed since last run, needsRegeneration will be true
  */
 export function shouldRegenerateRoutes(config) {
-    const versionsSuffix = (document) => (document.versions ? '.v' : '');
-    const authSuffix = (collection) => collection.auth ? `.${collection.auth.type}` : '';
     const memo = `
-    areas:${(config.areas || []).map((area) => `${area.slug}${versionsSuffix(area)}`).join(',')}
-    collections:${(config.collections || []).map((collection) => `${collection.slug}${authSuffix(collection)}${versionsSuffix(collection)}`).join(',')}
     custom:${config.panel?.routes
         ? Object.entries(config.panel.routes)
             .map(([k, v]) => `${k}-${slugify(v.component.toString())}`)
             .join(',')
         : ''}
     css:${config.panel?.css ? config.panel.css : 'none'}
+    collections:${(config.collections || []).map((c) => c.slug).join(',')}
+    areas:${(config.areas || []).map((a) => a.slug).join(',')}
   `;
     const cachedMemo = cache.get('routes');
     if (cachedMemo && cachedMemo === memo) {
@@ -102,13 +99,3 @@ export function writeRouteFile(basePath, routePath, fileType, content) {
     }
     fs.writeFileSync(path.join(dir, fileName), content);
 }
-/**
- * Cast slug in generated templates for document with versions
- * in order to prevent TS error that slug_versions is not a collection/area
- *
- * @example
- * castVersionSlug('pages_versions')
- * // output : 'pages_versions' as any
- * export const GET = api.collection.get('pages_versions' as any)
- */
-export const TScastVersionSlug = (slug) => hasVersionsSuffix(slug) || hasDirectoriesSuffix(slug) ? `'${slug}' as any` : `'${slug}'`;

package/dist/core/dev/generate/types/index.server.js

@@ -146,7 +146,7 @@ export async function generateTypesString(config) {
     const treeBlocksTypes = [];
     const registeredBlocks = [];
     const registeredTreeBlocks = [];
-    let imports = new Set(['BaseDoc', 'Navigation', 'User']);
+    let imports = new Set(['BaseDoc', 'Navigation', 'RouteHandlers', 'User']);
     const addImport = (string) => {
         imports = new Set([...imports, string]);
     };
@@ -297,8 +297,10 @@ export async function generateTypesString(config) {
 			>;
       /** Flag enabled by the core plugin rime.cache when the API cache is ON */
       cacheEnabled: boolean;
-      /** Available in panel, routes for sidebar */
-      routes: Navigation;
+      /** Available in panel, nav routes for sidebar */
+      navigation: Navigation;
+      /** Dispatch facade backing the fixed /panel/[slug]/... and /api/[slug]/... routes */
+      routes: RouteHandlers;
 			/**
 			 * Current locale if applicable
 			 * set following this prioroty :

package/dist/core/dev/vite/index.server.js

@@ -98,7 +98,7 @@ export function rime() {
         load(id) {
             const isServer = this.environment?.config?.consumer === 'server';
             if (id === resolvedVModule(VCoreId)) {
-                const corePath = isServer ? 'rimecms/config/server' : 'rimecms/config/client';
+                const corePath = isServer ? 'rimecms/config/server' : 'rimecms/config';
                 return `export * from '${corePath}';`;
             }
             if (id === resolvedVModule(VSchemaId) && isServer) {

package/dist/core/errors/handler.server.d.ts

@@ -2,13 +2,34 @@ export declare const ERROR_CONTEXT: {
     readonly ACTION: "action";
     readonly API: "api";
     readonly LOAD: "load";
-    readonly HANDLER: "handler";
 };
 export type ErrorContext = (typeof ERROR_CONTEXT)[keyof typeof ERROR_CONTEXT];
 type ErrorHandlerOptions = {
     context: ErrorContext;
     formData?: Record<string, any>;
 };
+/**
+ * Only called at the route boundary: +server.ts handlers, load functions,
+ * form actions. Everywhere else, just `throw new RimeError(...)` (centralizes
+ * error codes/messages) — it bubbles up and gets caught here, where `context`
+ * tells this function which SvelteKit primitive to translate it into:
+ * `error()` (api/load), `redirect()`, or `fail()` (action form errors).
+ *
+ * Always call it as `return handleError(...)`. Most branches throw internally
+ * (`error`/`redirect`), so `return` never runs — but the `fail()` branch (form
+ * errors in actions) is a real return value, so `return` is required there.
+ *
+ * @example +server.ts endpoint
+ * if (!id) return handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+ *
+ * @example load function
+ * const [err, doc] = await trycatch(() => getDoc(id));
+ * if (err) return handleError(err, { context: ERROR_CONTEXT.LOAD });
+ *
+ * @example form action
+ * const [err] = await trycatch(() => save(data));
+ * if (err) return handleError(err, { context: ERROR_CONTEXT.ACTION, formData: data });
+ */
 export declare function handleError(err: Error, options: ErrorHandlerOptions): import("@sveltejs/kit").ActionFailure<{
     form: Record<string, any>;
     errors: import("../../types.js").FormErrors;