rimecms 0.31.3 → 0.31.4

package/dist/core/config/auth/better-auth.server.js

@@ -1,6 +1,7 @@
 import { dev } from '$app/environment';
 import { env } from '$env/dynamic/public';
-import { admin as adminPlugin, apiKey } from 'better-auth/plugins';
+import { apiKey } from '@better-auth/api-key';
+import { admin as adminPlugin } from 'better-auth/plugins';
 import { betterAuthAfterHook, betterAuthBeforeHook } from './better-auth-hooks.server.js';
 import { accessControl, admin, staff, user } from './better-auth-permissions.js';
 export function getBaseAuthConfig(ctx) {

package/dist/core/config/server/write.server.js

@@ -1,5 +1,6 @@
 import { flatten } from 'flat';
 import cache from '../../dev/cache/index.server.js';
+import { CONFIG_DIR } from '../../dev/constants.js';
 /**
  * We actually need to serialize config values that will trigger
  * types, routes, or schema generations, meaning that for now
@@ -59,6 +60,10 @@ const writeMemo = (config) => {
             throw new Error(`Config error : Unable to parse value for key ${key}: ${err.message}`);
         }
     })
+        // Not part of the user's config object, but generated output (routes, schema, hooks) is
+        // relative to it — a RIME_CONFIG_DIR change must invalidate the memo just like a config
+        // change does, even when the config content itself is byte-identical.
+        .concat(`CONFIG_DIR:${CONFIG_DIR}`)
         .join('\n');
     const cached = cache.get('config');
     if (cached !== memoStr) {

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

@@ -2,14 +2,14 @@ import { RIME_DEV_CACHE_DIR } from '../../../constant.server.js';
 import { logger } from '../../../logger/index.server.js';
 import { rmSync } from 'node:fs';
 import path from 'node:path';
-import { INPUT_DIR, OUTPUT_DIR } from '../../constants.js';
+import { CONFIG_DIR, GENERATED_DIR } from '../../constants.js';
 import { prompt } from '../util/prompt.server.js';
 const clearMessage = `Are you sure you want to delete all related rime files (Y/n):
 - ./static/medias
 - ./db
 - ./src/routes/(rime)
-- ./src/lib/${INPUT_DIR}
-- ./src/lib/${OUTPUT_DIR}
+- ./${CONFIG_DIR}
+- ./${GENERATED_DIR}
 - ./src/app.generated.d.ts
 - ./src/rime.generated.d.ts
 - ./src/rime.modules.generated.d.ts
@@ -28,8 +28,8 @@ export const clear = async (args) => {
     // Remove directories
     rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
     rmSync(path.join('src', 'routes', '(rime)'), { recursive: true, force: true });
-    rmSync(path.join('src', 'lib', INPUT_DIR), { recursive: true, force: true });
-    rmSync(path.join('src', 'lib', OUTPUT_DIR), { recursive: true, force: true });
+    rmSync(CONFIG_DIR, { recursive: true, force: true });
+    rmSync(GENERATED_DIR, { recursive: true, force: true });
     rmSync(path.join('db'), { recursive: true, force: true });
     rmSync(path.join('static', 'medias'), { recursive: true, force: true });
     // Remove files

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

@@ -9,7 +9,7 @@ import { cp, mkdir } from 'fs/promises';
 import fs from 'node:fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { INPUT_DIR } from '../../constants.js';
+import { CONFIG_DIR, OUTPUT_DIR } from '../../constants.js';
 import { generate } from '../generate/index.server.js';
 import { installDependencies } from '../util/package-manager.server.js';
 import { getPackageInfoByKey } from '../util/package.server.js';
@@ -25,6 +25,7 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         const envUpdates = {
             BETTER_AUTH_SECRET: randomId(32),
             PUBLIC_RIME_URL: 'http://localhost:5173',
+            RIME_CONFIG_DIR: CONFIG_DIR,
             '# RIME_SMTP_USER': 'user@mail.com',
             '# RIME_SMTP_PASSWORD': 'supersecret',
             '# RIME_SMTP_PORT': '465',
@@ -53,7 +54,7 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         }
     }
     function setConfig(name) {
-        const configDirPath = path.resolve(root, 'src/lib', INPUT_DIR);
+        const configDirPath = path.resolve(root, CONFIG_DIR);
         const configPath = path.join(configDirPath, 'rime.config.server.ts');
         if (!existsSync(configPath)) {
             if (!existsSync(configDirPath)) {
@@ -83,21 +84,24 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
             return;
         }
         let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
+        // OUTPUT_DIR is derived from RIME_CONFIG_DIR, so its first character isn't always '+' —
+        // escape every regex metacharacter generically instead of hand-picking one to backslash.
+        const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const updates = [
-            '\\.cache',
+            '.cache',
             '/logs',
             '/db',
-            '\\+rime.generated',
+            OUTPUT_DIR,
             'src/app.generated.d.ts',
             'src/rime.generated.d.ts'
         ];
         if (!gitignoreContent.includes('# rime'))
             gitignoreContent += '\n# rime';
         for (const line of updates) {
-            const exists = gitignoreContent.match(new RegExp(`^${line}`, 'm'));
+            const exists = gitignoreContent.match(new RegExp(`^${escapeRegExp(line)}`, 'm'));
             if (!exists) {
                 // Add new value if doesn't exist
-                gitignoreContent += `\n${line.replace('\\', '')}`;
+                gitignoreContent += `\n${line}`;
             }
         }
         writeFileSync(gitignorePath, gitignoreContent);
@@ -108,10 +112,11 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         if (!existsSync(drizzleConfigPath)) {
             writeFileSync(drizzleConfigPath, templates.drizzleConfig(name.toString()));
             logger.info('[✓] Drizzle config added');
+            return;
         }
-        else {
-            logger.info('[✓] Drizzle config already exists (skip)');
-        }
+        logger.info(templates.regenerateDrizzleConfig(root)
+            ? '[✓] Drizzle config schema path updated'
+            : '[✓] Drizzle config already exists (skip)');
     }
     function configureVite() {
         const configPath = path.resolve(root, 'vite.config.ts');
@@ -182,23 +187,6 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         }
         return null;
     }
-    function setHooks() {
-        const hooksPath = path.join(root, 'src', 'hooks.server.ts');
-        const srcDir = path.join(root, 'src');
-        // Check if file exists
-        if (!existsSync(hooksPath)) {
-            // Ensure src directory exists
-            if (!existsSync(srcDir)) {
-                mkdirSync(srcDir, { recursive: true });
-            }
-            // Create hooks.server.ts with template content
-            writeFileSync(hooksPath, templates.hooks(), 'utf-8');
-            logger.info('[✓] hooks.server.ts created');
-        }
-        else {
-            logger.info('[✓] hooks.server.ts already exists (skip)');
-        }
-    }
     async function copyAssets() {
         try {
             const currentDir = path.dirname(fileURLToPath(import.meta.url));
@@ -219,7 +207,6 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         setConfig(name);
         setDatabase();
         setDrizzle(name);
-        setHooks();
         configureVite();
         await copyAssets();
         !skipInstall && installDependencies();
@@ -244,7 +231,6 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         setConfig(name);
         setDatabase();
         setDrizzle(name);
-        setHooks();
         configureVite();
         await copyAssets();
         !skipInstall && installDependencies();

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

@@ -2,3 +2,15 @@ export declare const env: () => string;
 export declare const defaultConfig: (name: string) => string;
 export declare const drizzleConfig: (name: string) => string;
 export declare const hooks: () => string;
+/** Writes src/hooks.server.ts if missing, or rewrites it if its content would differ from
+ * what's expected now (e.g. after RIME_CONFIG_DIR changes the import path) — called both at
+ * `rime init` and whenever the dev server detects a config change, so it never goes stale
+ * between the two. Returns whether it wrote anything. */
+export declare function regenerateHooks(root?: string): boolean;
+/** Patches drizzle.config.ts's schema path line if it's stale (e.g. after RIME_CONFIG_DIR
+ * changes) — only that one line, since the rest of the file may carry real customizations
+ * (verbose, custom fields, etc.). Must run before generateSchema()'s own drizzle-kit
+ * generate/migrate shell-out, which reads this file from disk. No-op if the file doesn't
+ * exist — creating it from scratch needs a project name, which is `rime init`'s job
+ * (setDrizzle() in init/index.server.ts). Returns whether it patched anything. */
+export declare function regenerateDrizzleConfig(root?: string): boolean;

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

@@ -1,8 +1,11 @@
 import { randomId } from '../../../../util/random.js';
-import { configImportPaths, OUTPUT_DIR } from '../../constants.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_DIR, GENERATED_DIR, configImportPaths } from '../../constants.js';
 const PACKAGE = 'rimecms';
 export const env = () => `BETTER_AUTH_SECRET=${randomId(32)}
 PUBLIC_RIME_URL=http://localhost:5173
+RIME_CONFIG_DIR=${CONFIG_DIR}
 
 # RIME_CACHE_ENABLED=false
 # RIME_SMTP_USER=user@mail.com
@@ -40,7 +43,7 @@ export const drizzleConfig = (name) => `
 import { defineConfig, type Config } from 'drizzle-kit';
 
 export const config: Config = {
-  schema: './src/lib/${OUTPUT_DIR}/schema.server.ts',
+  schema: './${GENERATED_DIR}/schema.server.ts',
   out: './db',
   strict: false,
   dialect: 'sqlite',
@@ -53,9 +56,50 @@ export default defineConfig(config);
 `;
 // 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.
+const HOOKS_DIR = path.resolve(process.cwd(), 'src');
 export const hooks = () => `import { sequence } from '@sveltejs/kit/hooks';
 import { handlers } from '${PACKAGE}/server';
-import config from '.${configImportPaths().server.replace('$lib', '/lib')}';
+import config from '${configImportPaths(HOOKS_DIR).server}';
 
 export const handle = sequence(...(await handlers(config)));
 `;
+/** Writes src/hooks.server.ts if missing, or rewrites it if its content would differ from
+ * what's expected now (e.g. after RIME_CONFIG_DIR changes the import path) — called both at
+ * `rime init` and whenever the dev server detects a config change, so it never goes stale
+ * between the two. Returns whether it wrote anything. */
+export function regenerateHooks(root = process.cwd()) {
+    const hooksPath = path.join(root, 'src', 'hooks.server.ts');
+    const srcDir = path.join(root, 'src');
+    const content = hooks();
+    if (!existsSync(hooksPath)) {
+        if (!existsSync(srcDir)) {
+            mkdirSync(srcDir, { recursive: true });
+        }
+        writeFileSync(hooksPath, content, 'utf-8');
+        return true;
+    }
+    if (readFileSync(hooksPath, 'utf-8') !== content) {
+        writeFileSync(hooksPath, content, 'utf-8');
+        return true;
+    }
+    return false;
+}
+const DRIZZLE_SCHEMA_LINE_REGEX = /^\s*schema:\s*['"][^'"]*['"],?\s*$/m;
+/** Patches drizzle.config.ts's schema path line if it's stale (e.g. after RIME_CONFIG_DIR
+ * changes) — only that one line, since the rest of the file may carry real customizations
+ * (verbose, custom fields, etc.). Must run before generateSchema()'s own drizzle-kit
+ * generate/migrate shell-out, which reads this file from disk. No-op if the file doesn't
+ * exist — creating it from scratch needs a project name, which is `rime init`'s job
+ * (setDrizzle() in init/index.server.ts). Returns whether it patched anything. */
+export function regenerateDrizzleConfig(root = process.cwd()) {
+    const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
+    if (!existsSync(drizzleConfigPath))
+        return false;
+    const expectedSchemaLine = `  schema: './${GENERATED_DIR}/schema.server.ts',`;
+    const content = readFileSync(drizzleConfigPath, 'utf-8');
+    if (DRIZZLE_SCHEMA_LINE_REGEX.test(content) && !content.includes(expectedSchemaLine)) {
+        writeFileSync(drizzleConfigPath, content.replace(DRIZZLE_SCHEMA_LINE_REGEX, expectedSchemaLine));
+        return true;
+    }
+    return false;
+}

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

@@ -1,15 +1,23 @@
-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(): {
+export declare const CONFIG_DIR: string;
+export declare const GENERATED_DIR: string;
+export declare const INPUT_DIR: string;
+export declare const OUTPUT_DIR: string;
+/** Turns an absolute path into an import specifier relative to `fromDir`, always prefixed
+ * with `./` or `../` so it never gets mistaken for a bare package specifier. */
+export declare function relativeImportSpecifier(fromDir: string, toAbsolutePath: string): string;
+export declare function generatedConfigServerPath(): string;
+/** Where the panel/live route templates (common.server.ts) and the generated hooks.server.ts
+ * should import the client/server config from — a relative import specifier computed from
+ * `fromDir` (the absolute directory of the file doing the importing), so it resolves whether
+ * GENERATED_DIR lives under src/lib or elsewhere. One source of truth instead of hardcoding the
+ * path (or relying on the $lib alias, which only ever points at src/lib) at each call site. */
+export declare function configImportPaths(fromDir: string): {
     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;
+export declare function schemaPath(projectRoot?: 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,19 +1,58 @@
+import dotenv from 'dotenv';
 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() {
+// Must run before RIME_CONFIG_DIR is read below. ES import hoisting evaluates this module's
+// top-level code before any *importing* file's own top-level statements — including a
+// dotenv.config() call there — so loading .env here, first, is the only way every entry point
+// (CLI, dev-server, drizzle.config.ts, etc.) reliably sees it. override:true so .env is the
+// explicit source of truth, not whatever a shell plugin (autoenv, direnv, ...) already exported
+// from some other project's .env. The only dotenv.config() call in the codebase — a second one
+// elsewhere would race this one.
+dotenv.config({ override: true });
+const root = process.cwd();
+const SRC_ROOT = path.resolve(root, 'src');
+export const CONFIG_DIR = process.env.RIME_CONFIG_DIR || 'src/+rime';
+export const GENERATED_DIR = `${CONFIG_DIR}.generated`;
+export const INPUT_DIR = path.basename(CONFIG_DIR);
+export const OUTPUT_DIR = `${INPUT_DIR}.generated`;
+const RESERVED_DIRS = new Set(['lib', 'routes', 'static', 'params'].map((d) => path.resolve(SRC_ROOT, d)));
+for (const dir of [CONFIG_DIR, GENERATED_DIR]) {
+    const resolved = path.resolve(root, dir);
+    if (resolved === SRC_ROOT || !resolved.startsWith(SRC_ROOT + path.sep)) {
+        throw new Error(`RIME_CONFIG_DIR must resolve to a subdirectory of ${SRC_ROOT} (got "${dir}")`);
+    }
+    if (RESERVED_DIRS.has(resolved)) {
+        throw new Error(`RIME_CONFIG_DIR must not be src/lib, src/routes, src/static, or src/params (got "${dir}")`);
+    }
+}
+/** Turns an absolute path into an import specifier relative to `fromDir`, always prefixed
+ * with `./` or `../` so it never gets mistaken for a bare package specifier. */
+export function relativeImportSpecifier(fromDir, toAbsolutePath) {
+    const rel = path.relative(fromDir, toAbsolutePath).split(path.sep).join('/');
+    return rel.startsWith('.') ? rel : `./${rel}`;
+}
+/** Root-relative filesystem path (posix-style) to a file inside the generated config dir —
+ * for Vite's ssrLoadModule, which wants a real file path, not an import specifier. */
+function generatedFilePath(file) {
+    return path.relative(root, path.resolve(root, GENERATED_DIR, file)).split(path.sep).join('/');
+}
+export function generatedConfigServerPath() {
+    return generatedFilePath('rime.config.server.ts');
+}
+/** Where the panel/live route templates (common.server.ts) and the generated hooks.server.ts
+ * should import the client/server config from — a relative import specifier computed from
+ * `fromDir` (the absolute directory of the file doing the importing), so it resolves whether
+ * GENERATED_DIR lives under src/lib or elsewhere. One source of truth instead of hardcoding the
+ * path (or relying on the $lib alias, which only ever points at src/lib) at each call site. */
+export function configImportPaths(fromDir) {
     return {
-        client: `$lib/${OUTPUT_DIR}/rime.config.js`,
-        server: `$lib/${OUTPUT_DIR}/rime.config.server.js`
+        client: relativeImportSpecifier(fromDir, path.resolve(root, GENERATED_DIR, 'rime.config.js')),
+        server: relativeImportSpecifier(fromDir, path.resolve(root, GENERATED_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');
+export function schemaPath(projectRoot = process.cwd()) {
+    return path.resolve(projectRoot, GENERATED_DIR, 'schema.server.ts');
 }
 /**
  * True when `metaUrl` (pass the caller's own `import.meta.url` — this can't be one shared

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

@@ -1,5 +1,8 @@
 import { PACKAGE_NAME } from '../../../constant.server.js';
+import path from 'node:path';
 import { configImportPaths } from '../../constants.js';
+const PANEL_LAYOUT_DIR = path.resolve(process.cwd(), 'src/routes/(rime)/panel');
+const LIVE_PAGE_DIR = path.resolve(process.cwd(), 'src/routes/(rime)/panel/live-edit');
 /**
  * Main base layout
  * /+layout.server.ts
@@ -146,7 +149,7 @@ export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.r
 const panelLayout = () => `
 <script>
   import { Panel } from '${PACKAGE_NAME}/panel';
-	import config from '${configImportPaths().client}';
+	import config from '${configImportPaths(PANEL_LAYOUT_DIR).client}';
 
 	const { children, data } = $props();
 	
@@ -196,7 +199,7 @@ export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.d
 const livePage = () => `
 <script>
   import { Live } from '${PACKAGE_NAME}/panel';
-  import config from '${configImportPaths().client}';
+  import config from '${configImportPaths(LIVE_PAGE_DIR).client}';
 
   const { data } = $props();
 </script>

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

@@ -5,7 +5,7 @@ import { babelParse } from 'ast-kit';
 import fs from 'node:fs';
 import path from 'node:path';
 import { logger } from '../../../logger/index.server.js';
-import { INPUT_DIR, OUTPUT_DIR } from '../../constants.js';
+import { CONFIG_DIR, GENERATED_DIR, OUTPUT_DIR } from '../../constants.js';
 
 /**
  * $ prefix-based sanitizer that rules:
@@ -22,8 +22,8 @@ const TOP_LEVEL_CONFIG = 'rime.config.server.ts';
 
 export async function sanitize() {
   const root = process.cwd();
-  const configDir = path.resolve(root, 'src/lib/', INPUT_DIR);
-  const outputDir = path.resolve(root, 'src/lib/', OUTPUT_DIR);
+  const configDir = path.resolve(root, CONFIG_DIR);
+  const outputDir = path.resolve(root, GENERATED_DIR);
 
   logger.info('Sanitizing config...');
 

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

@@ -12,7 +12,7 @@ import { trycatchSync } from '../../../../util/function.js';
 import { capitalize, toPascalCase } from '../../../../util/string.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { isInstalledDependency, OUTPUT_DIR } from '../../constants.js';
+import { GENERATED_DIR, isInstalledDependency, relativeImportSpecifier } from '../../constants.js';
 const IS_RIME_REPO = !isInstalledDependency(import.meta.url);
 // Relation  type
 const relationValueType = `
@@ -259,7 +259,8 @@ export async function generateTypesString(config) {
     const blocksTypeNames = `export type BlockTypes = ${registeredBlocks.map((name) => `'${name}'`).join('|')}\n`;
     const anyBlock = `export type AnyBlock = ${registeredBlocks.map((name) => `Block${toPascalCase(name)}`).join('|')}\n`;
     const typeImports = `import type { ${Array.from(imports).join(', ')} } from '${PACKAGE_NAME}/types'`;
-    const rimeConfigServerPath = `./lib/${OUTPUT_DIR}/rime.config.server.ts`;
+    // app.generated.d.ts always sits at src/app.generated.d.ts (see generateTypes() below).
+    const rimeConfigServerPath = relativeImportSpecifier(path.resolve(process.cwd(), 'src'), path.resolve(process.cwd(), GENERATED_DIR, 'rime.config.server.ts'));
     const locals = `declare global {
   namespace App {
     interface Locals {

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

@@ -1,15 +1,13 @@
-import dotenv from 'dotenv';
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
 import { ensureHasInit } from '../../ensure.server.js';
 import { logger } from '../../logger/index.server.js';
 import { getPackageInfoByKey } from '../cli/util/package.server.js';
-import { INPUT_DIR, isInstalledDependency, OUTPUT_DIR, schemaPath } from '../constants.js';
+import { CONFIG_DIR, GENERATED_DIR, generatedConfigServerPath, isInstalledDependency, schemaPath } from '../constants.js';
 import { findInstalledPackageRoot, findModulePair, scanModulePairs } from '../generate/runtime/index.server.js';
 import { parseExportNames } from '../generate/runtime/parse-exports.server.js';
 import { sanitize } from '../generate/sanitize/index.server.js';
-dotenv.config({ override: true });
 const dev = process.env.NODE_ENV === 'development';
 /** Picks the client or server side of a module.(server.)ts pair. When the requested side
  *  wasn't authored (e.g. a collection's $url/$hooks, real only server-side, imported anyway by
@@ -132,9 +130,8 @@ export function rime() {
                     try {
                         // ssrLoadModule wants the real .ts file path, not a $lib/*.js-style import
                         // specifier — different consumer than configImportPaths() (used for generated
-                        // source code), so computed directly here.
-                        const serverConfigPath = `src/lib/${OUTPUT_DIR}/rime.config.server.ts`;
-                        const mod = await server.ssrLoadModule(serverConfigPath);
+                        // source code).
+                        const mod = await server.ssrLoadModule(generatedConfigServerPath());
                         // The config's default export is the createRime() promise; ssrLoadModule
                         // only awaits the module's synchronous evaluation, so we must await it
                         // directly to observe init errors (e.g. invalid config) here instead of
@@ -153,8 +150,7 @@ export function rime() {
                 }
             }
             server.watcher.on('change', (modulePath) => {
-                const isConfigChange = modulePath.includes(`src/lib/${INPUT_DIR}`) &&
-                    !modulePath.includes(`src/lib/${OUTPUT_DIR}`);
+                const isConfigChange = modulePath.includes(CONFIG_DIR) && !modulePath.includes(GENERATED_DIR);
                 if (!isConfigChange)
                     return;
                 if (reloadTimer)

package/dist/core/ensure.server.d.ts

@@ -1,10 +1,10 @@
 import type { BuiltCollection } from '../types.js';
 /**
- * Ensure sanitize config exists — the generated server config inside rime.generated/.
+ * Ensure sanitize config exists — the generated server config inside the generated config dir.
  */
 export declare function ensureGeneratedConfig(): string;
 /**
- * Ensure user config exists — the src/lib/+rime/ folder convention.
+ * Ensure user config exists — the CONFIG_DIR folder convention.
  */
 export declare function ensureUserConfigExist(): void;
 /**

package/dist/core/ensure.server.js

@@ -1,25 +1,34 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
-import { INPUT_DIR, OUTPUT_DIR, schemaPath } from './dev/constants.js';
+import { CONFIG_DIR, GENERATED_DIR, generatedConfigServerPath, schemaPath } from './dev/constants.js';
 const projectRoot = process.cwd();
 /**
- * Ensure sanitize config exists — the generated server config inside rime.generated/.
+ * Ensure sanitize config exists — the generated server config inside the generated config dir.
  */
 export function ensureGeneratedConfig() {
-    const configGeneratedPath = path.resolve(projectRoot, 'src/lib', OUTPUT_DIR, 'rime.config.server.ts');
+    const configGeneratedPath = path.resolve(projectRoot, GENERATED_DIR, 'rime.config.server.ts');
     if (!existsSync(configGeneratedPath)) {
         throw new Error('Unable to find generated config');
     }
-    return path.join('$lib', OUTPUT_DIR, 'rime.config.server.js');
+    return generatedConfigServerPath();
 }
 /**
- * Ensure user config exists — the src/lib/+rime/ folder convention.
+ * Ensure user config exists — the CONFIG_DIR folder convention.
  */
 export function ensureUserConfigExist() {
-    const folderConfig = path.resolve(projectRoot, 'src/lib', INPUT_DIR, 'rime.config.server.ts');
-    if (!existsSync(folderConfig)) {
-        throw new Error('Unable to find config, did you run rime init');
+    const folderConfig = path.resolve(projectRoot, CONFIG_DIR, 'rime.config.server.ts');
+    if (existsSync(folderConfig))
+        return;
+    // Every project set up before RIME_CONFIG_DIR existed has its config here — if it's there
+    // but not at CONFIG_DIR, this is almost certainly an upgrade whose .env predates the env
+    // var, not a missing init, so say that instead of the generic message.
+    const LEGACY_DEFAULT = 'src/lib/+rime';
+    if (CONFIG_DIR !== LEGACY_DEFAULT &&
+        existsSync(path.resolve(projectRoot, LEGACY_DEFAULT, 'rime.config.server.ts'))) {
+        throw new Error(`Unable to find config at ${CONFIG_DIR} — found one at ${LEGACY_DEFAULT} instead. ` +
+            `Set RIME_CONFIG_DIR=${LEGACY_DEFAULT} in your .env to keep using it there, or move it to ${CONFIG_DIR} to match the current default.`);
     }
+    throw new Error('Unable to find config, did you run rime init');
 }
 /**
  * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to

package/dist/core/handlers/auth.server.js

@@ -70,12 +70,11 @@ async function handleApiKeyAuth(headers, user, auth) {
     const result = await auth.api.verifyApiKey({
         body: { key: apiKey }
     });
-    if (!result.valid || !result.key || typeof result.key.permissions !== 'string') {
+    if (!result.valid || !result.key || !result.key.permissions) {
         logger.error(RimeError.UNAUTHORIZED, 'Invalid api key');
         throw error(401, RimeError.UNAUTHORIZED);
     }
-    const permissions = JSON.parse(result.key.permissions);
-    user.roles = permissions.roles;
+    user.roles = result.key.permissions.roles;
 }
 /**
  * Builds complete user data by combining auth and CMS information