rimecms 0.30.3 → 0.31.0

package/dist/core/config/types.d.ts

@@ -1,8 +1,8 @@
 import type { Adapter } from '../../adapter-sqlite/index.server.js';
 import type { PanelLanguage } from '../i18n/index.js';
 import type { Hook, HookBeforeOperation } from '../operations/hooks/index.server.js';
-import type { Plugin, PluginClient } from '../plugins/index.js';
-import type { SMTPConfig } from '../plugins/mailer/index.server.js';
+import type { Plugin } from '../plugins/index.js';
+import type { SMTPConfig } from '../plugins/mailer/module.server.js';
 import type { Field, Option } from '../../fields/types.js';
 import type { RegisterArea, RegisterCollection } from '../../index.js';
 import type { DashboardEntry } from '../../panel/pages/dashboard/types.js';
@@ -79,10 +79,9 @@ export interface Config {
      * }
      */
     $routes?: Record<string, RouteConfig>;
-    /** List of client plugins */
-    plugins?: PluginClient[];
-    /** List of server plugins */
-    $plugins?: Plugin[];
+    /** List of plugins — safety for anything server-only inside one comes from the
+     * $rime/.../module convention, not from a $-prefix on this key */
+    plugins?: Plugin[];
     /** Custom object for server-only config additional values  */
     $custom?: Record<string, any>;
     /** Custom object for both client and server config additional values  */
@@ -309,7 +308,7 @@ export type BuiltCollection = Omit<Collection<string>, 'icon' | 'versions' | 'up
     _generateSchema?: false;
     _generateRoutes?: false;
 };
-export type BuiltAreaClient = Omit<BuiltArea, '$url' | '$hooks'>;
+export type BuiltAreaClient = BuiltArea;
 export type BuiltArea = Omit<Area<string>, 'versions'> & {
     slug: AreaSlug;
     type: 'area';
@@ -326,7 +325,7 @@ export type BuiltArea = Omit<Area<string>, 'versions'> & {
     _generateSchema?: false;
     _generateRoutes?: false;
 };
-export type BuiltCollectionClient = Omit<BuiltCollection, '$url' | '$hooks'>;
+export type BuiltCollectionClient = BuiltCollection;
 export type BuiltConfig = {
     /** Database location relative to the root project ex: ./db/my-app.sqlite */
     $database: string;
@@ -341,8 +340,10 @@ export type BuiltConfig = {
     icons: Record<string, any>;
     $trustedOrigins: string[];
     $routes?: Record<string, RouteConfig>;
+    /** Fully-resolved plugin list, computed by augmentPluginsServer — internal, not the
+     * consumer-facing config key (that's just `plugins`) */
     $plugins?: Plugin[];
-    plugins?: PluginClient[];
+    plugins?: Plugin[];
     panel: {
         routes: Record<string, CustomPanelRoute>;
         navigation: NavigationConfig;
@@ -366,12 +367,12 @@ export type BuiltConfig = {
     $custom?: Record<string, any>;
     custom?: Record<string, any>;
 };
-export type ServerConfigProps = '$adapter' | '$database' | '$trustedOrigins' | '$routes' | '$smtp' | '$custom' | '$plugins' | '$auth';
+export type ServerConfigProps = '$adapter' | '$database' | '$trustedOrigins' | '$routes' | '$smtp' | '$custom' | '$auth';
 export type SanitizedConfigClient = Omit<Config, ServerConfigProps | 'collections' | 'areas'> & {
     collections?: BuiltCollectionClient[];
     areas?: BuiltAreaClient[];
 };
-export type BuiltConfigClient = Omit<BuiltConfig, ServerConfigProps | 'panel' | 'collections' | 'areas'> & {
+export type BuiltConfigClient = Omit<BuiltConfig, ServerConfigProps | '$plugins' | 'panel' | 'collections' | 'areas'> & {
     collections: BuiltCollectionClient[];
     areas: BuiltAreaClient[];
     icons: Dic<Component<IconProps>>;

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

@@ -1,6 +1,6 @@
-import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
 import fs from 'fs';
 import path from 'path';
+import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
 const dev = process.env.NODE_ENV === 'development';
 if (!fs.existsSync(RIME_DEV_CACHE_DIR) && dev) {
     fs.mkdirSync(RIME_DEV_CACHE_DIR);

package/dist/core/dev/cli/clear/index.server.js

@@ -12,6 +12,7 @@ const clearMessage = `Are you sure you want to delete all related rime files (Y/
 - ./src/lib/${OUTPUT_DIR}
 - ./src/app.generated.d.ts
 - ./src/rime.generated.d.ts
+- ./src/rime.modules.generated.d.ts
 - ./src/hooks.server.ts
 - ./drizzle.config.ts
 `;
@@ -35,6 +36,7 @@ export const clear = async (args) => {
     rmSync(path.join('src', 'hooks.server.ts'), { force: true });
     rmSync(path.join('src', 'app.generated.d.ts'), { force: true });
     rmSync(path.join('src', 'rime.generated.d.ts'), { force: true });
+    rmSync(path.join('src', 'rime.modules.generated.d.ts'), { force: true });
     rmSync(path.join('drizzle.config.ts'), { force: true });
     return logger.info('rime cleared');
 };

package/dist/core/dev/cli/generate-manifest/index.server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Run at prepack, after `svelte-package` (operates on the compiled `dist/`, not `src/lib`) —
+ * makes this package's own `$rime/modules` splits consumable by anyone who installs it:
+ *
+ * 1. Builds an export-name → split index from every module.(server.)js pair under `dist/`,
+ *    validating it as it goes (see `buildModuleIndex` below) — a name that resolves
+ *    ambiguously has no correct rewrite target in step 2, so this has to fail loudly here,
+ *    not silently later.
+ * 2. AST-rewrites every `import ... from '$rime/modules'` found anywhere under `dist/` into
+ *    one `import ... from '$rime/modules/<pkg>/<subpath>'` per split it actually draws from —
+ *    the bare barrel form never survives past this step.
+ * 3. Writes `dist/.rime-modules.json` (subpath → real file paths, read directly by a
+ *    consumer's Vite plugin — no fs.existsSync probing, no guessing) and
+ *    `dist/.rime-modules.d.ts` (one `declare module '$rime/modules/<pkg>/<subpath>'` per
+ *    split, referenced by a consumer's generated types).
+ */
+export declare const generateManifest: () => void;

package/dist/core/dev/cli/generate-manifest/index.server.js

@@ -0,0 +1,221 @@
+import { generate } from '@babel/generator';
+import * as t from '@babel/types';
+import { babelParse } from 'ast-kit';
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../../../logger/index.server.js';
+import { scanModulePairs } from '../../generate/runtime/index.server.js';
+import { parseExportNames } from '../../generate/runtime/parse-exports.server.js';
+import { getPackageInfoByKey } from '../util/package.server.js';
+/**
+ * Run at prepack, after `svelte-package` (operates on the compiled `dist/`, not `src/lib`) —
+ * makes this package's own `$rime/modules` splits consumable by anyone who installs it:
+ *
+ * 1. Builds an export-name → split index from every module.(server.)js pair under `dist/`,
+ *    validating it as it goes (see `buildModuleIndex` below) — a name that resolves
+ *    ambiguously has no correct rewrite target in step 2, so this has to fail loudly here,
+ *    not silently later.
+ * 2. AST-rewrites every `import ... from '$rime/modules'` found anywhere under `dist/` into
+ *    one `import ... from '$rime/modules/<pkg>/<subpath>'` per split it actually draws from —
+ *    the bare barrel form never survives past this step.
+ * 3. Writes `dist/.rime-modules.json` (subpath → real file paths, read directly by a
+ *    consumer's Vite plugin — no fs.existsSync probing, no guessing) and
+ *    `dist/.rime-modules.d.ts` (one `declare module '$rime/modules/<pkg>/<subpath>'` per
+ *    split, referenced by a consumer's generated types).
+ */
+export const generateManifest = () => {
+    const pkgName = getPackageInfoByKey('name');
+    if (!pkgName) {
+        throw new Error("$rime generate-manifest: could not read this package's own name from package.json");
+    }
+    const distDir = path.resolve(process.cwd(), 'dist');
+    if (!fs.existsSync(distDir)) {
+        throw new Error(`$rime generate-manifest: no dist/ at ${distDir} — run this after svelte-package, not before`);
+    }
+    const pairs = scanModulePairs(distDir);
+    const nameOwner = buildModuleIndex(pairs);
+    rewriteBarrelImports(distDir, pkgName, nameOwner);
+    writeManifest(distDir, pkgName, pairs);
+    logger.info(`[✓] $rime/modules manifest generated for ${pkgName} (${pairs.size} split(s))`);
+};
+/**
+ * Export-name → split index, with the two collision scenarios from the design doc handled
+ * distinctly:
+ * - module.ts and module.server.ts of the *same* split sharing a name — not a collision, that's
+ *   the whole point of a pair (skip, both sides collapse to one entry). The two sides don't
+ *   need to export the *same set* of names either — a server-only helper the client build
+ *   never needs (e.g. cache's own `toHash`) is completely normal, not a broken pair; indexed
+ *   from the union of both sides, worth a log for visibility, never a blocking error.
+ * - two *different* splits exporting the same name — the actual collision. An ambiguous
+ *   `$rime/modules` import has no correct rewrite target, so this is a hard error here, not a
+ *   warning: it has to be caught before the rewrite runs, not after.
+ */
+function buildModuleIndex(pairs) {
+    const nameOwner = new Map();
+    for (const [subpath, entry] of pairs) {
+        const serverNames = entry.server ? parseExportNames(entry.server) : [];
+        const clientNames = entry.client ? parseExportNames(entry.client) : [];
+        if (entry.server && entry.client) {
+            const serverSet = new Set(serverNames);
+            const clientSet = new Set(clientNames);
+            const onlyServer = serverNames.filter((name) => !clientSet.has(name));
+            const onlyClient = clientNames.filter((name) => !serverSet.has(name));
+            if (onlyServer.length || onlyClient.length) {
+                logger.debug(`$rime/modules: ${subpath} — module.ts and module.server.ts export different names ` +
+                    `(server-only: ${onlyServer.join(', ') || 'none'}, client-only: ${onlyClient.join(', ') || 'none'})`);
+            }
+        }
+        const names = new Set([...serverNames, ...clientNames]);
+        for (const name of names) {
+            const existing = nameOwner.get(name);
+            if (existing && existing !== subpath) {
+                throw new Error(`$rime/modules: "${name}" exported by both ${existing} and ${subpath}`);
+            }
+            nameOwner.set(name, subpath);
+        }
+    }
+    return nameOwner;
+}
+/**
+ * `dist/.rime-modules.json` (runtime, read by a consumer's Vite plugin) and
+ * `dist/.rime-modules.d.ts` (types, referenced by a consumer's generated types).
+ *
+ * Both store paths *relative to `distDir`*, not absolute — confirmed in practice that an
+ * absolute path here is a real bug, not just a style choice: it bakes in wherever `dist/`
+ * happened to sit on the machine that ran `generate-manifest`, and a consumer's Vite plugin
+ * (`vite/index.server.ts`'s `load()`, third-party qualified form) re-joins it onto the
+ * *installed* package's own root (`findInstalledPackageRoot`) at read time. On a real install
+ * that absolute path wouldn't even exist; on the same dev machine the package was authored on
+ * it silently reads the author's own working-copy `dist/` instead of what's actually installed
+ * in the consumer's `node_modules` - stale-looking field/behavior drift with no error raised.
+ *
+ * The `.d.ts` needs a *different* relative shape than the runtime manifest, verified directly
+ * (a real `tsc` run — a plain filesystem path, absolute or relative, silently resolves to zero
+ * exports inside a `declare module` block; only a bare package-qualified specifier, resolved
+ * through the same `node_modules` mechanism a real import would use, actually works): every
+ * `export *` target is `<pkgName>/dist/<subpath-relative-to-dist>`.
+ */
+function writeManifest(distDir, pkgName, pairs) {
+    const manifest = {};
+    const dts = [];
+    const relativeToDist = (target) => path.relative(distDir, target).split(path.sep).join('/');
+    for (const [subpath, entry] of pairs) {
+        manifest[subpath] = {
+            client: entry.client ? relativeToDist(entry.client) : undefined,
+            server: entry.server ? relativeToDist(entry.server) : undefined
+        };
+        const target = entry.server || entry.client;
+        const bareSpecifier = `${pkgName}/dist/${relativeToDist(target)}`.replace(/\.ts$/, '.js');
+        dts.push(`declare module '$rime/modules/${pkgName}/${subpath}' {\n  export * from '${bareSpecifier}';\n}`);
+    }
+    fs.writeFileSync(path.join(distDir, '.rime-modules.json'), JSON.stringify(manifest));
+    fs.writeFileSync(path.join(distDir, '.rime-modules.d.ts'), dts.join('\n\n') + '\n');
+}
+/**
+ * Walks every `.js`/`.d.ts` file under `dist/`, rewriting `import ... from '$rime/modules'`
+ * into one `import ... from '$rime/modules/<pkg>/<subpath>'` per split its specifiers actually
+ * draw from — a single barrel import can (and often will) pull names from several different
+ * splits at once, each becoming its own import statement.
+ *
+ * Every rewritten `.d.ts` file also gets a `/// <reference path="...">` to `.rime-modules.d.ts`
+ * prepended, making it self-contained — verified directly (a real `tsc` run): without it, a
+ * consumer never discovers the ambient `declare module '$rime/modules/<pkg>/...'` declarations
+ * at all, *even from a file inside this same package*, since nothing imports `.rime-modules.d.ts`
+ * and it's outside any project's own `include`. Doing it here means the *consumer* never needs
+ * to know this package exists just to get its types working — no eager, app-side aggregation
+ * of every installed rime-dependent package required.
+ */
+function rewriteBarrelImports(distDir, pkgName, nameOwner) {
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+                continue;
+            }
+            if (!entry.name.endsWith('.js') && !entry.name.endsWith('.d.ts'))
+                continue;
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            if (!content.includes('$rime/modules'))
+                continue;
+            const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: true });
+            let changed = false;
+            const newBody = [];
+            for (const node of ast.body) {
+                // `import { x } from '$rime/modules'` (runtime .js) and the equivalent re-export
+                // `export { x } from '$rime/modules'` (declaration .d.ts, what tsc/svelte-package
+                // actually emits — a real end-to-end run caught this, not something guessable) both
+                // need the same treatment.
+                if (t.isImportDeclaration(node) && node.source.value === '$rime/modules') {
+                    changed = true;
+                    newBody.push(...splitBarrelImport(node, fullPath, pkgName, nameOwner));
+                    continue;
+                }
+                if (t.isExportNamedDeclaration(node) && node.source?.value === '$rime/modules') {
+                    changed = true;
+                    newBody.push(...splitBarrelReExport(node, fullPath, pkgName, nameOwner));
+                    continue;
+                }
+                if (t.isExportAllDeclaration(node) && node.source.value === '$rime/modules') {
+                    throw new Error(`$rime/modules: ${fullPath} does 'export * from $rime/modules' — ambiguous, can't tell which split each re-exported name belongs to. Import/re-export specific names instead.`);
+                }
+                newBody.push(node);
+            }
+            if (changed) {
+                ast.body = newBody;
+                const { code } = generate(ast, { compact: false, comments: true });
+                fs.writeFileSync(fullPath, entry.name.endsWith('.d.ts') ? withManifestReference(code, fullPath, distDir) : code);
+            }
+        }
+    };
+    walk(distDir);
+}
+function withManifestReference(code, fullPath, distDir) {
+    const relative = path
+        .relative(path.dirname(fullPath), path.join(distDir, '.rime-modules.d.ts'))
+        .split(path.sep)
+        .join('/');
+    const referencePath = relative.startsWith('.') ? relative : `./${relative}`;
+    return `/// <reference path="${referencePath}" />\n${code}`;
+}
+/** `import { x } from '$rime/modules'` (runtime .js) — groups specifiers by which split each
+ *  name actually belongs to (via `nameOwner`, built by `buildModuleIndex`), one import
+ *  statement per split. */
+function splitBarrelImport(node, fullPath, pkgName, nameOwner) {
+    const bySubpath = new Map();
+    for (const spec of node.specifiers) {
+        if (!t.isImportSpecifier(spec)) {
+            throw new Error(`$rime/modules: ${fullPath} imports the barrel with a default/namespace specifier — only named imports are supported`);
+        }
+        const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+        const subpath = nameOwner.get(importedName);
+        if (!subpath) {
+            throw new Error(`$rime/modules: '${importedName}' imported in ${fullPath} but not exported by any split`);
+        }
+        if (!bySubpath.has(subpath))
+            bySubpath.set(subpath, []);
+        bySubpath.get(subpath).push(spec);
+    }
+    return Array.from(bySubpath.entries()).map(([subpath, specs]) => t.importDeclaration(specs, t.stringLiteral(`$rime/modules/${pkgName}/${subpath}`)));
+}
+/** `export { x } from '$rime/modules'` — what `tsc`/`svelte-package` actually emits in `.d.ts`
+ *  output (a real end-to-end run caught this; `import`+`export` pairs aren't the only shape).
+ *  Same grouping as `splitBarrelImport`, just keyed off `.local` (the name as it exists in the
+ *  source module) instead of `.imported` — `ExportSpecifier` doesn't have that field. */
+function splitBarrelReExport(node, fullPath, pkgName, nameOwner) {
+    const bySubpath = new Map();
+    for (const spec of node.specifiers) {
+        if (!t.isExportSpecifier(spec)) {
+            throw new Error(`$rime/modules: ${fullPath} re-exports the barrel with a default/namespace specifier — only named exports are supported`);
+        }
+        const localName = spec.local.name;
+        const subpath = nameOwner.get(localName);
+        if (!subpath) {
+            throw new Error(`$rime/modules: '${localName}' re-exported in ${fullPath} but not exported by any split`);
+        }
+        if (!bySubpath.has(subpath))
+            bySubpath.set(subpath, []);
+        bySubpath.get(subpath).push(spec);
+    }
+    return Array.from(bySubpath.entries()).map(([subpath, specs]) => t.exportNamedDeclaration(null, specs, t.stringLiteral(`$rime/modules/${pkgName}/${subpath}`)));
+}

package/dist/core/dev/cli/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { logger } from '../../logger/index.server.js';
+import { spawnSync } from 'node:child_process';
 import { program } from 'commander';
 import { existsSync, writeFileSync } from 'fs';
 import { envProduction } from './build/templates.js';
@@ -44,6 +45,47 @@ program
         process.exitCode = 1;
     }
 });
+program
+    .command('package')
+    .description("Builds a rime plugin/field package for publish: svelte-kit sync, svelte-package, then " +
+    'generate-manifest — makes any $rime/modules splits it exports consumable by anyone who ' +
+    'installs it. Equivalent to chaining those three yourself.')
+    .action(() => {
+    const sync = spawnSync('./node_modules/.bin/svelte-kit', ['sync'], { stdio: 'inherit' });
+    if (sync.status !== 0) {
+        process.exitCode = sync.status ?? 1;
+        return;
+    }
+    const build = spawnSync('./node_modules/.bin/svelte-package', [], { stdio: 'inherit' });
+    if (build.status !== 0) {
+        process.exitCode = build.status ?? 1;
+        return;
+    }
+    import('./generate-manifest/index.server.js').then(({ generateManifest }) => {
+        try {
+            generateManifest();
+        }
+        catch (error) {
+            logger.error(error.message);
+            process.exitCode = 1;
+        }
+    });
+});
+program
+    .command('generate-manifest')
+    .description("Run after svelte-package, before publish — makes this package's own $rime/modules " +
+    'splits consumable by anyone who installs it (rewrites the barrel into qualified ' +
+    'imports in dist/, writes dist/.rime-modules.json + .d.ts).')
+    .action(async () => {
+    const generateManifest = await import('./generate-manifest/index.server.js').then((m) => m.generateManifest);
+    try {
+        generateManifest();
+    }
+    catch (error) {
+        logger.error(error.message);
+        process.exitCode = 1;
+    }
+});
 program
     .command('env')
     .option('-f, --force', 'Force generation, overwrite current', false)

package/dist/core/dev/cli/init/index.server.js

@@ -54,13 +54,13 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
     }
     function setConfig(name) {
         const configDirPath = path.resolve(root, 'src/lib', INPUT_DIR);
-        const configPath = path.join(configDirPath, 'rime.config.ts');
+        const configPath = path.join(configDirPath, 'rime.config.server.ts');
         if (!existsSync(configPath)) {
             if (!existsSync(configDirPath)) {
                 mkdirSync(configDirPath);
             }
             writeFileSync(configPath, templates.defaultConfig(name.toString()));
-            logger.info(`[✓] Config created at ${configDirPath}/rime.config.ts`);
+            logger.info(`[✓] Config created at ${configDirPath}/rime.config.server.ts`);
         }
         else {
             logger.info('[✓] Config already exists (skip)');
@@ -83,7 +83,14 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
             return;
         }
         let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
-        const updates = ['\\.cache', '/logs', '/db', '\\+rime.generated'];
+        const updates = [
+            '\\.cache',
+            '/logs',
+            '/db',
+            '\\+rime.generated',
+            'src/app.generated.d.ts',
+            'src/rime.generated.d.ts'
+        ];
         if (!gitignoreContent.includes('# rime'))
             gitignoreContent += '\n# rime';
         for (const line of updates) {
@@ -185,7 +192,7 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
                 mkdirSync(srcDir, { recursive: true });
             }
             // Create hooks.server.ts with template content
-            writeFileSync(hooksPath, templates.hooks, 'utf-8');
+            writeFileSync(hooksPath, templates.hooks(), 'utf-8');
             logger.info('[✓] hooks.server.ts created');
         }
         else {

package/dist/core/dev/cli/init/templates.d.ts

@@ -1,4 +1,4 @@
 export declare const env: () => string;
 export declare const defaultConfig: (name: string) => string;
 export declare const drizzleConfig: (name: string) => string;
-export declare const hooks = "import { sequence } from '@sveltejs/kit/hooks';\nimport { handlers } from 'rimecms/server';\nimport config from './lib/+rime.generated/rime.config.server.js';\n\nexport const handle = sequence(...(await handlers(config)));\n";
+export declare const hooks: () => string;

package/dist/core/dev/cli/init/templates.js

@@ -1,5 +1,5 @@
 import { randomId } from '../../../../util/random.js';
-import { OUTPUT_DIR } from '../../constants.js';
+import { configImportPaths, OUTPUT_DIR } from '../../constants.js';
 const PACKAGE = 'rimecms';
 export const env = () => `BETTER_AUTH_SECRET=${randomId(32)}
 PUBLIC_RIME_URL=http://localhost:5173
@@ -51,9 +51,11 @@ export const config: Config = {
 
 export default defineConfig(config);
 `;
-export const hooks = `import { sequence } from '@sveltejs/kit/hooks';
+// Regenerated fresh by rime init every time (setHooks() only skips if the file already
+// exists, and `rime clear`/useConfig.js delete it first) — safe to make mode-aware.
+export const hooks = () => `import { sequence } from '@sveltejs/kit/hooks';
 import { handlers } from '${PACKAGE}/server';
-import config from './lib/${OUTPUT_DIR}/rime.config.server.js';
+import config from '.${configImportPaths().server.replace('$lib', '/lib')}';
 
 export const handle = sequence(...(await handlers(config)));
 `;

package/dist/core/dev/cli/util/package-manager.server.js

@@ -9,22 +9,24 @@ const packageManagersMap = {
     npm: 'package-lock.json',
     deno: 'deno.lock'
 };
+const deps = ['drizzle-orm', '@libsql/client', '@lucide/svelte', 'sharp'];
+const devDeps = ['@sveltejs/adapter-node', 'drizzle-kit'];
 const packageManagerConfigs = {
     yarn: {
         command: 'echo "yarn is not supported, please use pnpm or npm" && exit 1'
     },
     pnpm: {
-        command: 'pnpm add -D drizzle-kit && pnpm add -D @sveltejs/adapter-node && pnpm add drizzle-orm @libsql/client @lucide/svelte sharp',
+        command: `pnpm add -D ${devDeps.join(' ')} && pnpm add ${deps.join(' ')}`,
         preInstall: configurePnpm,
         postInstall: () => {
             execSync('pnpm rebuild');
         }
     },
     bun: {
-        command: 'bun add -D drizzle-kit && bun add -D @sveltejs/adapter-node && bun add drizzle-orm @libsql/client @lucide/svelte sharp'
+        command: `bun add -D ${devDeps.join(' ')} && bun add ${deps.join(' ')}`
     },
     npm: {
-        command: 'npm install -D drizzle-kit && npm install -D @sveltejs/adapter-node && npm install drizzle-orm @libsql/client @lucide/svelte sharp'
+        command: `npm install -D ${devDeps.join(' ')} && npm install ${deps.join(' ')}`
     },
     deno: {
         command: 'echo "deno is not supported, please use pnpm or npm" && exit 1'

package/dist/core/dev/constants.d.ts

@@ -1,5 +1,15 @@
 export declare const OUTPUT_DIR = "+rime.generated";
 export declare const INPUT_DIR = "+rime";
+/** Where the panel/live route templates (common.server.ts) should import the client config
+ * from, and where the dev-server watcher/hot-reload should read the server config from —
+ * one source of truth instead of hardcoding the path at each call site. */
+export declare function configImportPaths(): {
+    client: string;
+    server: string;
+};
+/** Same idea as configImportPaths — one source of truth for where the generated schema
+ * lives instead of hardcoding the path at each call site. */
+export declare function schemaPath(root?: string): string;
 /**
  * True when `metaUrl` (pass the caller's own `import.meta.url` — this can't be one shared
  * value, it depends on which file is asking) is running from inside an installed `rimecms`

package/dist/core/dev/constants.js

@@ -1,5 +1,20 @@
+import path from 'node:path';
 export const OUTPUT_DIR = '+rime.generated';
 export const INPUT_DIR = '+rime';
+/** Where the panel/live route templates (common.server.ts) should import the client config
+ * from, and where the dev-server watcher/hot-reload should read the server config from —
+ * one source of truth instead of hardcoding the path at each call site. */
+export function configImportPaths() {
+    return {
+        client: `$lib/${OUTPUT_DIR}/rime.config.js`,
+        server: `$lib/${OUTPUT_DIR}/rime.config.server.js`
+    };
+}
+/** Same idea as configImportPaths — one source of truth for where the generated schema
+ * lives instead of hardcoding the path at each call site. */
+export function schemaPath(root = process.cwd()) {
+    return path.resolve(root, 'src/lib', OUTPUT_DIR, 'schema.server.ts');
+}
 /**
  * True when `metaUrl` (pass the caller's own `import.meta.url` — this can't be one shared
  * value, it depends on which file is asking) is running from inside an installed `rimecms`

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

@@ -1,8 +1,5 @@
 import { PACKAGE_NAME } from '../../../constant.server.js';
-import { OUTPUT_DIR } from '../../constants.js';
-// Trick to prevent svelte-kit to replace $lib with resolved imports path
-// same thing for PACKAGE_NAME
-const DOLLAR_LIB = '$lib';
+import { configImportPaths } from '../../constants.js';
 /**
  * Main base layout
  * /+layout.server.ts
@@ -149,8 +146,8 @@ export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.r
 const panelLayout = () => `
 <script>
   import { Panel } from '${PACKAGE_NAME}/panel';
-	import config from '${DOLLAR_LIB}/${OUTPUT_DIR}/rime.config.js';
-	
+	import config from '${configImportPaths().client}';
+
 	const { children, data } = $props();
 	
 	const user = $derived.by(() => {
@@ -199,7 +196,7 @@ export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.d
 const livePage = () => `
 <script>
   import { Live } from '${PACKAGE_NAME}/panel';
-  import config from '${DOLLAR_LIB}/${OUTPUT_DIR}/rime.config.js';
+  import config from '${configImportPaths().client}';
 
   const { data } = $props();
 </script>

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

@@ -30,15 +30,36 @@ function generateRoutes(config) {
     ensureDir(rimeRoutes);
     ensureDir(panelRoute);
     ensureDir(paramsDir);
-    // 3. Process common routes (now includes the matcher-disambiguated [slug=collection|area] routes)
+    // 3. Process common routes (now includes the matcher-disambiguated [slug=collection|area] routes) —
+    // skip the [slug=collection]/[slug=area] routes and their matchers when there are no collections/areas
+    // configured, rather than generating a matcher that can never match anything.
+    const hasCollections = (config.collections || []).length > 0;
+    const hasAreas = (config.areas || []).length > 0;
     for (const [pattern, files] of Object.entries(commonRoutes)) {
+        if (!hasCollections && pattern.includes('[slug=collection]'))
+            continue;
+        if (!hasAreas && pattern.includes('[slug=area]'))
+            continue;
         for (const [fileType, templateFn] of Object.entries(files)) {
             writeRouteFile(rootRoutes, pattern, fileType, templateFn());
         }
     }
-    // 4. Write the [slug=collection]/[slug=area] param matchers
-    fs.writeFileSync(path.join(paramsDir, 'collection.ts'), paramMatcher((config.collections || []).map((c) => c.kebab)));
-    fs.writeFileSync(path.join(paramsDir, 'area.ts'), paramMatcher((config.areas || []).map((a) => a.kebab)));
+    // 4. Write the [slug=collection]/[slug=area] param matchers, only when needed — and remove any
+    // stale matcher left over from a previous config that did have collections/areas.
+    const collectionMatcherPath = path.join(paramsDir, 'collection.ts');
+    if (hasCollections) {
+        fs.writeFileSync(collectionMatcherPath, paramMatcher((config.collections || []).map((c) => c.kebab)));
+    }
+    else {
+        fs.rmSync(collectionMatcherPath, { force: true });
+    }
+    const areaMatcherPath = path.join(paramsDir, 'area.ts');
+    if (hasAreas) {
+        fs.writeFileSync(areaMatcherPath, paramMatcher((config.areas || []).map((a) => a.kebab)));
+    }
+    else {
+        fs.rmSync(areaMatcherPath, { force: true });
+    }
     // 5. Handle custom routes from config
     const customRoutes = config.panel?.routes;
     if (customRoutes) {