rimecms 0.31.5 → 0.32.1

package/dist/core/dev/codegen/routes/common.server.d.ts

@@ -0,0 +1,35 @@
+import type { Routes } from './util.server.js';
+/**
+ * A prototype's REST endpoint, one file per declared sub-path.
+ *
+ * There is no per-kind template any more: `name`, `path` and `methods` all come from what the
+ * prototype declared in its own `rest/index.server.ts`, so an area's file has no POST for the
+ * same reason an area has no create — nobody declared one. An undeclared method stays
+ * unexported and SvelteKit answers it with its own 405, exactly as before.
+ *
+ * The body dispatches by name and path (see `rest` in handlers/routes.server.ts) so this file,
+ * like every other generated route, imports nothing from rimecms.
+ *
+ * (rime)/api/[slug=<name>]/<path>/+server.ts
+ */
+declare const prototypeApiServer: (name: string, path: string, methods: string[]) => string;
+/**
+ * Param matchers backing [slug=<prototype>] — 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.
+ *
+ * One file per prototype name, named *after* that prototype — see the loop in
+ * index.server.ts, where that naming is what makes `[slug=collection]` mean
+ * "a slug of the collection prototype".
+ * src/params/<prototype>.ts
+ */
+declare const paramMatcher: (slugs: string[]) => string;
+/**
+ * Custom route template generator
+ * Used for generating custom routes
+ */
+declare const customRoute: (config: any) => string;
+export declare const commonRoutes: Routes;
+export { customRoute, paramMatcher, prototypeApiServer };

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

@@ -0,0 +1,437 @@
+import { PACKAGE_NAME } from '../../../constants.server.js';
+import path from 'node:path';
+import { configImportPaths } from '../../constants.server.js';
+const PANEL_LAYOUT_DIR = path.resolve(process.cwd(), 'src/routes/(rime)/[panel=panel]');
+const LIVE_PAGE_DIR = path.resolve(process.cwd(), 'src/routes/(rime)/[panel=panel]/live-edit');
+/**
+ * Main base layout
+ * /+layout.server.ts
+ */
+const mainLayout = () => `
+import { toPublicUser } from '${PACKAGE_NAME}/server';
+import type { ServerLoadEvent } from '@sveltejs/kit';
+export const load = async ({ locals }: ServerLoadEvent) => {
+	return { user: toPublicUser(locals.user) };
+};`;
+/**
+ * Error page template
+ * (rime)/+error.svelte
+ */
+const error = () => `
+<script>
+  import { page } from '$app/state';
+</script>
+
+<div class="rz-error">
+  <h1>Error {page.status}</h1>
+  |
+  <p>
+    {page.error?.message}
+  </p>
+</div>
+
+<style>
+  .rz-error {
+    height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 1rem;
+    h1 {
+      font-size: 1.5rem;
+      font-weight: semibold;
+    }
+  }
+</style>
+`;
+/**
+ * Root layout template
+ * (rime)/+layout.svelte
+ */
+const rootLayout = () => `
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	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 } };
+
+	const { children, data }: Props = $props();
+	
+	// svelte-ignore state_referenced_locally
+	i18n.init(data.translations);
+</script>
+
+<div class="rz-root">
+	{@render children()}
+</div>`;
+/**
+ * Root layout server template
+ * (rime)/+layout.server.ts
+ */
+const rootLayoutServer = () => `
+import type { ServerLoadEvent } from '@sveltejs/kit';
+import { registerTranslation, toPublicUser } from '${PACKAGE_NAME}/server';
+
+export const ssr = false;
+
+export const load = async ({ locals }: ServerLoadEvent) => {
+	const { user, rime } = locals;
+	const translations = await registerTranslation(rime.config.raw.panel.language);
+	// Public here: this layout also covers sign-in/forgot-password/reset-password. The
+	// panel's own nested layout (panelLayoutServer) re-supplies the full user for panel
+	// pages, overriding this on the way down.
+	return { user: toPublicUser(user), translations };
+};`;
+/**
+ * Login page template
+ * (rime)/[panel=panel]/sign-in/+page.svelte
+ */
+const signInPage = () => `
+<script>
+  import { SignIn } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<SignIn {data} />`;
+/**
+ * Login page server template
+ * (rime)/auth/sign-in/+page@(rime).server.ts
+ */
+const signInPageServer = () => `
+import { type ServerLoadEvent, type RequestEvent } from '@sveltejs/kit';
+
+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
+ * (rime)/[panel=panel]/forgot-password/+page.svelte
+ */
+const forgotPasswordPage = () => `
+<script>
+  import { ForgotPassword } from '${PACKAGE_NAME}/panel'
+  const { data } = $props();
+</script>
+<ForgotPassword {data} />`;
+/**
+ * Forgot password page server template
+ * (rime)/[panel=panel]/forgot-password/+page.server.ts
+ */
+const forgotPasswordPageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.forgotPassword(event);
+`;
+/**
+ * Reset password page template
+ * (rime)/[panel=panel]/reset-password/+page.svelte
+ */
+const resetPasswordPage = () => `
+<script>
+  import { ResetPassword } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<ResetPassword {data} />`;
+/**
+ * Reset password page server template
+ * (rime)/[panel=panel]/reset-password/+page.server.ts
+ */
+const resetPasswordPageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.resetPassword(event);
+`;
+/**
+ * Panel layout template
+ * (rime)/[panel=panel]/+layout.svelte
+ */
+const panelLayout = () => `
+<script>
+  import { Panel } from '${PACKAGE_NAME}/panel';
+	import config from '${configImportPaths(PANEL_LAYOUT_DIR).client}';
+
+	const { children, data } = $props();
+	
+	const user = $derived.by(() => {
+		if (!data.user) throw new Error('unauthorized');
+		return data.user;
+	});
+</script>
+
+<Panel {config} {user} routes={data.routes} locale={data.locale}>
+	{@render children()}
+</Panel>`;
+/**
+ * Panel layout server template
+ * (rime)/[panel=panel]/+layout.server.ts
+ */
+const panelLayoutServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = async ({ locals }: ServerLoadEvent) => {
+  const { user, locale, navigation } = locals;
+  return { user, locale, routes: navigation };
+};`;
+/**
+ * Panel page template
+ * (rime)/[panel=panel]/+page.svelte
+ */
+const panelPage = () => `
+<script>
+  import { Dashboard } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<Dashboard entries={data.entries} user={data.user} />`;
+/**
+ * Panel page load template
+ * (rime)/[panel=panel]/+page.server.ts
+ */
+const panelPageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.dashboard(event);`;
+/**
+ * Live page template
+ * (rime)/live/+page.svelte
+ */
+const livePage = () => `
+<script>
+  import { Live } from '${PACKAGE_NAME}/panel';
+  import config from '${configImportPaths(LIVE_PAGE_DIR).client}';
+
+  const { data } = $props();
+</script>
+
+
+<Live {data} config={config} />`;
+/**
+ * Live page server template
+ * (rime)/live/+page.server.ts
+ */
+const livePageServer = () => `
+import { type ServerLoadEvent } from '@sveltejs/kit';
+
+export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.live(event);`;
+/****************************************************/
+/* The panel's /[slug=<prototype>]/... routes — fixed, generic,
+/* matcher-disambiguated, generated once regardless of how many prototypes of
+/* that kind are configured. The per-prototype param matchers (src/params/,
+/* see paramMatcher below) route each slug to the right folder at the
+/* SvelteKit router level, so a collection page and an area page 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.
+/*
+/* These stay written out per kind while the panel does: its loads, actions
+/* and components are per-kind too, so generating the routes from the
+/* registry alone would move that seam rather than close it. The /api tree,
+/* whose handlers a prototype now declares, is generated instead — see
+/* prototypeApiServer below.
+/****************************************************/
+/**
+ * Collection list page
+ * (rime)/[panel=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=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=panel]/[slug=area]/+page.svelte
+ */
+const areaDocPage = () => `
+<script>
+  import { Area } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<Area {data} />`;
+/**
+ * (rime)/[panel=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=panel]/[slug=collection]/[id]/+page.svelte
+ */
+const collectionDocPage = () => `
+<script>
+  import { CollectionDoc } from '${PACKAGE_NAME}/panel';
+  const { data } = $props();
+</script>
+
+<CollectionDoc {data} />`;
+/**
+ * (rime)/[panel=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)
+};`;
+/**
+ * A prototype's REST endpoint, one file per declared sub-path.
+ *
+ * There is no per-kind template any more: `name`, `path` and `methods` all come from what the
+ * prototype declared in its own `rest/index.server.ts`, so an area's file has no POST for the
+ * same reason an area has no create — nobody declared one. An undeclared method stays
+ * unexported and SvelteKit answers it with its own 405, exactly as before.
+ *
+ * The body dispatches by name and path (see `rest` in handlers/routes.server.ts) so this file,
+ * like every other generated route, imports nothing from rimecms.
+ *
+ * (rime)/api/[slug=<name>]/<path>/+server.ts
+ */
+const prototypeApiServer = (name, path, methods) => `
+import { type RequestEvent } from '@sveltejs/kit';
+
+const handle = (event: RequestEvent) => event.locals.routes.rest('${name}', '${path}', event);
+
+${methods.map((method) => `export const ${method} = handle;`).join('\n')}`;
+/**
+ * Param matchers backing [slug=<prototype>] — 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.
+ *
+ * One file per prototype name, named *after* that prototype — see the loop in
+ * index.server.ts, where that naming is what makes `[slug=collection]` mean
+ * "a slug of the collection prototype".
+ * src/params/<prototype>.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
+ */
+const customRoute = (config) => {
+    let componentPath = '';
+    let componentName = '';
+    const rawPath = typeof config.component === 'string'
+        ? config.component
+        : config.component[Symbol.for('filename')] || config.component[Symbol('filename')];
+    if (rawPath) {
+        const componentReg = /([A-Z][a-zA-Z0-9]+)\.svelte$/;
+        const match = rawPath.match(componentReg);
+        if (match) {
+            componentName = match[1];
+            if (rawPath.includes('node_modules/')) {
+                componentPath = 'node_modules/' + rawPath.split('node_modules/').at(-1);
+            }
+            else {
+                componentPath = '$lib/' + rawPath.split('lib/').at(-1);
+            }
+        }
+    }
+    if (componentName && componentPath) {
+        return `<script lang="ts">
+  import ${componentName} from '${componentPath}'
+  const { data } = $props()
+</script>
+<${componentName} {data} />`;
+    }
+    return `Cannot parse provided component path`;
+};
+// Shared routes dictionary
+export const commonRoutes = {
+    '': {
+        layoutServer: mainLayout
+    },
+    '(rime)': {
+        layout: rootLayout,
+        layoutServer: rootLayoutServer,
+        error: error
+    },
+    '(rime)/[panel=panel]/sign-in': {
+        'page@(rime)': signInPage,
+        pageServer: signInPageServer
+    },
+    '(rime)/[panel=panel]/forgot-password': {
+        'page@(rime)': forgotPasswordPage,
+        pageServer: forgotPasswordPageServer
+    },
+    '(rime)/[panel=panel]/reset-password': {
+        'page@(rime)': resetPasswordPage,
+        pageServer: resetPasswordPageServer
+    },
+    '(rime)/[panel=panel]': {
+        layout: panelLayout,
+        layoutServer: panelLayoutServer,
+        page: panelPage,
+        pageServer: panelPageServer
+    },
+    '(rime)/[panel=panel]/live-edit': {
+        'page@(rime)': livePage,
+        pageServer: livePageServer
+    },
+    '(rime)/[panel=panel]/[slug=collection]': {
+        page: collectionListPage,
+        pageServer: collectionListPageServer
+    },
+    '(rime)/[panel=panel]/[slug=collection]/[id]': {
+        page: collectionDocPage,
+        pageServer: collectionDocPageServer
+    },
+    '(rime)/[panel=panel]/[slug=area]': {
+        page: areaDocPage,
+        pageServer: areaDocPageServer
+    },
+    '(rime)/api/[...rest]': {
+        server: apiCatchAllServer
+    }
+};
+export { customRoute, paramMatcher, prototypeApiServer };

package/dist/core/dev/codegen/routes/custom-css.server.js

@@ -0,0 +1,86 @@
+import { logger } from '../../../logger.server.js';
+import fs from 'fs';
+/**
+ * Injects a custom CSS link into the layout file
+ * @param layoutFilePath Path to the layout file
+ * @param cssPath Custom CSS path from config
+ * @example
+ * // Inject custom CSS into a layout file
+ * const layoutPath = '/path/to/src/routes/(rime)/+layout.svelte';
+ * const cssPath = '/assets/custom-styles.css';
+ * injectCustomCSS(layoutPath, cssPath);
+ * // This will add a <svelte:head> tag with a link to the CSS file
+ */
+export function injectCustomCSS(layoutFilePath, cssPath) {
+    try {
+        if (fs.existsSync(layoutFilePath)) {
+            const content = fs.readFileSync(layoutFilePath, 'utf8');
+            // Check if the file already has a svelte:head tag
+            if (content.includes('<svelte:head>')) {
+                // Check if the CSS link is already in the file
+                if (content.includes(cssPath)) {
+                    return; // CSS link already exists
+                }
+                // Replace the existing svelte:head tag with a new one that includes the CSS link
+                const headRegex = /(<svelte:head>)(.*?)(<\/svelte:head>)/s;
+                const cssLink = `\n  <link rel="stylesheet" href="${cssPath}" />\n  `;
+                const newContent = content.replace(headRegex, `$1$2${cssLink}$3`);
+                // Write the updated content back to the file
+                fs.writeFileSync(layoutFilePath, newContent, 'utf8');
+                logger.info(`Custom CSS link added in ${layoutFilePath}`);
+            }
+            else {
+                // No svelte:head tag, so insert one after the script tag
+                const scriptEndIndex = content.indexOf('</script>') + '</script>'.length;
+                if (scriptEndIndex > 0) {
+                    const beforeScript = content.substring(0, scriptEndIndex);
+                    const afterScript = content.substring(scriptEndIndex);
+                    const cssLink = `\n\n<svelte:head>\n  <link rel="stylesheet" href="${cssPath}" />\n</svelte:head>`;
+                    const newContent = beforeScript + cssLink + afterScript;
+                    // Write the updated content back to the file
+                    fs.writeFileSync(layoutFilePath, newContent, 'utf8');
+                    logger.info(`Custom CSS link added in ${layoutFilePath}`);
+                }
+                else {
+                    logger.error(`Could not find insertion point in ${layoutFilePath}`);
+                }
+            }
+        }
+        else {
+            logger.error(`Layout file not found: ${layoutFilePath}`);
+        }
+    }
+    catch (err) {
+        logger.error(`Error injecting custom CSS into layout file: ${err}`);
+    }
+}
+/**
+ * Removes any custom CSS link from the layout file
+ * @param layoutFilePath Path to the layout file
+ * @example
+ * // Remove custom CSS from a layout file
+ * const layoutPath = '/path/to/src/routes/(rime)/+layout.svelte';
+ * removeCustomCSS(layoutPath);
+ * // This will remove any <svelte:head> tag and its contents from the layout file
+ */
+export function removeCustomCSS(layoutFilePath) {
+    try {
+        if (fs.existsSync(layoutFilePath)) {
+            let content = fs.readFileSync(layoutFilePath, 'utf8');
+            if (content.includes('<svelte:head>')) {
+                // Remove the svelte:head tag and its contents
+                const headRegex = /<svelte:head>.*?<\/svelte:head>/s;
+                content = content.replace(headRegex, '');
+                // Write the updated content back to the file
+                fs.writeFileSync(layoutFilePath, content, 'utf8');
+                logger.info(`[✓] Custom CSS link removed from ${layoutFilePath}`);
+            }
+        }
+        else {
+            logger.error(`Layout file not found: ${layoutFilePath}`);
+        }
+    }
+    catch (err) {
+        logger.error(`Error removing custom CSS from layout file: ${err}`);
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Config } from '../../../../types.js';
+/**
+ * Main function to generate browser routes based on configuration.
+ *
+ * Every file written here is a fixed set of dynamic-segment routes — the count never grows with
+ * how many collections or areas are configured, only with how many prototype *kinds* exist and
+ * what each one declares. `commonRoutes` holds the ones that are the same for everybody plus the
+ * panel's own [slug=<name>] tree; the /api tree is written from each prototype's `rest`
+ * declaration, so this file names no kind of its own.
+ *
+ * The folder is always the literal `[panel=panel]` segment; only src/params/panel.ts's matcher
+ * content varies with RIME_PANEL_ROUTE, so the URL itself can be hidden from admin-path scanners
+ * without ever renaming a directory. The per-prototype matchers work the same way, baking in the
+ * actual slug list — all of them are rewritten here.
+ */
+declare function generateRoutes<T extends Config>(config: T): void;
+export default generateRoutes;

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

@@ -0,0 +1,110 @@
+import { logger } from '../../../logger.server.js';
+import { area } from '../../../prototype/area/definition.server.js';
+import { collection } from '../../../prototype/collection/definition.server.js';
+import { PANEL_ROUTE } from '../../../routes/constants.server.js';
+import fs from 'fs';
+import path from 'path';
+import { commonRoutes, customRoute, paramMatcher, prototypeApiServer } 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.
+ *
+ * Every file written here is a fixed set of dynamic-segment routes — the count never grows with
+ * how many collections or areas are configured, only with how many prototype *kinds* exist and
+ * what each one declares. `commonRoutes` holds the ones that are the same for everybody plus the
+ * panel's own [slug=<name>] tree; the /api tree is written from each prototype's `rest`
+ * declaration, so this file names no kind of its own.
+ *
+ * The folder is always the literal `[panel=panel]` segment; only src/params/panel.ts's matcher
+ * content varies with RIME_PANEL_ROUTE, so the URL itself can be hidden from admin-path scanners
+ * without ever renaming a directory. The per-prototype matchers work the same way, baking in the
+ * actual slug list — all of them are rewritten here.
+ */
+function generateRoutes(config) {
+    logger.info('Routes generation...');
+    // 1. Check if routes need to be regenerated
+    if (!shouldRegenerateRoutes(config)) {
+        return;
+    }
+    // 2. Ensure base directories exist
+    const rootRoutes = path.resolve(projectRoot, 'src', 'routes');
+    const rimeRoutes = path.join(rootRoutes, '(rime)');
+    const panelRoute = path.join(rimeRoutes, '[panel=panel]');
+    const paramsDir = path.resolve(projectRoot, 'src', 'params');
+    fs.rmSync(rimeRoutes, { recursive: true, force: true });
+    ensureDir(rootRoutes);
+    ensureDir(rimeRoutes);
+    ensureDir(panelRoute);
+    ensureDir(paramsDir);
+    // 3. The URL segments each prototype accepts, by prototype name. A name with none configured
+    // gets no routes and no matcher — generating a matcher that can never match anything would
+    // leave SvelteKit with a route no request can reach.
+    const prototypes = [collection, area];
+    const kebabsByPrototype = {
+        collection: (config.collections || []).map((c) => c.kebab),
+        area: (config.areas || []).map((a) => a.kebab)
+    };
+    // 4. Process common routes — the fixed files plus the panel's own
+    // [panel=panel]/[slug=<name>]/... tree. A pattern naming a matcher is skipped when that
+    // matcher will not exist, read off the pattern itself rather than from a per-kind boolean.
+    const matcherIn = (pattern) => pattern.match(/\[slug=([^\]]+)\]/)?.[1];
+    for (const [pattern, files] of Object.entries(commonRoutes)) {
+        const matcher = matcherIn(pattern);
+        if (matcher && !kebabsByPrototype[matcher]?.length)
+            continue;
+        for (const [fileType, templateFn] of Object.entries(files)) {
+            writeRouteFile(rootRoutes, pattern, fileType, templateFn());
+        }
+    }
+    // 5. The /api tree, written from what each prototype declared in its own rest/index.server.ts
+    // — so an endpoint exists because a definition says so, and codegen never names a kind.
+    for (const prototype of prototypes) {
+        if (!kebabsByPrototype[prototype.name]?.length)
+            continue;
+        for (const [routePath, routeConfig] of Object.entries(prototype.rest || {})) {
+            const methods = Object.keys(routeConfig);
+            if (!methods.length)
+                continue;
+            const pattern = path.join(`(rime)/api/[slug=${prototype.name}]`, routePath);
+            writeRouteFile(rootRoutes, pattern, 'server', prototypeApiServer(prototype.name, routePath, methods));
+        }
+    }
+    // 6. Param matchers. The [panel=panel] one is always present; the rest are one per prototype
+    // name, and **the file name is the prototype name** — that is what makes `[slug=collection]`
+    // in a route pattern mean "a slug of the collection prototype", and the whole reason nothing
+    // above needs a list of kinds. A matcher whose prototype has no configs is removed, so a
+    // stale one from a previous config cannot keep matching.
+    fs.writeFileSync(path.join(paramsDir, 'panel.ts'), paramMatcher([PANEL_ROUTE]));
+    for (const prototype of prototypes) {
+        const matcherPath = path.join(paramsDir, `${prototype.name}.ts`);
+        const kebabs = kebabsByPrototype[prototype.name];
+        if (kebabs?.length) {
+            fs.writeFileSync(matcherPath, paramMatcher(kebabs));
+        }
+        else {
+            fs.rmSync(matcherPath, { force: true });
+        }
+    }
+    // 7. Handle custom routes from config
+    const customRoutes = config.panel?.routes;
+    if (customRoutes) {
+        for (const [route, routeConfig] of Object.entries(customRoutes)) {
+            const routePath = path.join('(rime)', '[panel=panel]', route);
+            writeRouteFile(rootRoutes, routePath, 'page', customRoute(routeConfig));
+        }
+    }
+    // 8. Handle custom CSS in layout file
+    const layoutPath = path.join(rimeRoutes, '+layout.svelte');
+    if (fs.existsSync(layoutPath)) {
+        if (config.panel?.css) {
+            injectCustomCSS(layoutPath, config.panel.css);
+        }
+        else {
+            removeCustomCSS(layoutPath);
+        }
+    }
+    logger.info('[✓] Routes generated');
+}
+export default generateRoutes;