rimecms 0.27.6 → 0.28.1

package/dist/core/config/server/build-config.server.d.ts

@@ -1137,7 +1137,7 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
                         $Infer: {
                             body: {
                                 userId: string;
-                                role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
+                                role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
                             };
                         };
                     };
@@ -1217,7 +1217,7 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
                                 email: string;
                                 password?: string | undefined;
                                 name: string;
-                                role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
+                                role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
                                 data?: Record<string, any> | undefined;
                             };
                         };
@@ -1761,7 +1761,7 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
                                 permission?: never | undefined;
                             }) & {
                                 userId?: string | undefined;
-                                role?: "user" | "staff" | "admin" | undefined;
+                                role?: "user" | "admin" | "staff" | undefined;
                             };
                         };
                     };
@@ -3119,7 +3119,7 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
                             $Infer: {
                                 body: {
                                     userId: string;
-                                    role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
+                                    role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
                                 };
                             };
                         };
@@ -3199,7 +3199,7 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
                                     email: string;
                                     password?: string | undefined;
                                     name: string;
-                                    role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
+                                    role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
                                     data?: Record<string, any> | undefined;
                                 };
                             };
@@ -3743,7 +3743,7 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
                                     permission?: never | undefined;
                                 }) & {
                                     userId?: string | undefined;
-                                    role?: "user" | "staff" | "admin" | undefined;
+                                    role?: "user" | "admin" | "staff" | undefined;
                                 };
                             };
                         };
@@ -3956,12 +3956,12 @@ export declare const buildConfig: <const C extends Config>(config: C) => Promise
     };
 }>;
 declare function augmentConfig<T extends Config>(config: T): T & {
-    readonly collections: readonly [import("../types.js").BuiltCollection, ...import("../types.js").BuiltCollection[]];
+    readonly collections: readonly [...import("../types.js").BuiltCollection[], import("../types.js").BuiltCollection];
 } & {
     readonly collections: import("../types.js").BuiltCollection[];
     readonly areas: import("../types.js").BuiltArea[];
 } & {
-    readonly icons: import("../../../util/types.js").Dic<import("svelte").Component<import("@lucide/svelte").IconProps, {}, string>>;
+    readonly icons: import("../../../util/types.js").Dic<import("svelte").Component<import("@lucide/svelte").LucideProps, {}, string>>;
 } & {
     readonly panel: {
         readonly routes: Record<string, import("../types.js").CustomPanelRoute>;
@@ -3972,16 +3972,16 @@ declare function augmentConfig<T extends Config>(config: T): T & {
                 icon: import("svelte").Component<import("@lucide/svelte").IconProps>;
             }[], {
                 readonly label: "content";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").IconProps, {}, "">;
+                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
             }, {
                 readonly label: "system";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").IconProps, {}, "">;
+                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
             }, {
                 readonly label: "collections";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").IconProps, {}, "">;
+                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
             }, {
                 readonly label: "areas";
-                readonly icon: import("svelte").Component<import("@lucide/svelte").IconProps, {}, "">;
+                readonly icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
             }];
         };
         readonly components: {

package/dist/core/config/server/build-config.server.js

@@ -4,7 +4,7 @@ import { augmentPlugins } from '../client/augment-plugins.js';
 import { augmentIcons } from '../shared/augment-icons.js';
 import { augmentPrototypes } from '../shared/augment-prototypes.js';
 import { makeVersionsCollectionsAliases } from '../shared/versions-alias.server.js';
-import { augmentCORS } from './augment-cors.js';
+import { augmentCORS } from './augment-cors.server.js';
 import { augmentDirectoriesServer } from './augment-directories.server.js';
 import { augmentPanelAccess } from './augment-panel-access.server.js';
 import { augmentPluginsServer } from './augment-plugins.server.js';

package/dist/core/config/server/{validate.js → validate.server.js}

@@ -1,10 +1,12 @@
 import { isAuthConfig } from '../../collections/auth/util.js';
-import cache from '../../dev/cache/index.js';
+import cache from '../../dev/cache/index.server.js';
 import { isFormField } from '../../fields/util.js';
+import { logger } from '../../logger/index.server';
 import { isBlocksFieldRaw } from '../../../fields/blocks/index.js';
 import { isGroupFieldRaw } from '../../../fields/group/index.js';
+import { isRelationField } from '../../../fields/relation';
 import { isSelectField } from '../../../fields/select/index.js';
-import { isTabsFieldRaw } from '../../../fields/tabs/index.js';
+import { isTabsFieldRaw } from '../../../fields/tabs';
 import { isTreeFieldRaw } from '../../../fields/tree/index.js';
 function hasDuplicates(arr) {
     return [...new Set(arr.filter((e, i, a) => a.indexOf(e) !== i))];
@@ -45,11 +47,11 @@ function hasUsersSlug(config) {
 const validateFields = (config) => {
     let errors = [];
     for (const collection of config.collections || []) {
-        const collectionErrors = validateDocumentFields(collection);
+        const collectionErrors = validateDocumentFields(collection, config);
         errors = [...errors, ...collectionErrors];
     }
     for (const area of config.areas || []) {
-        const collectionErrors = validateDocumentFields(area);
+        const collectionErrors = validateDocumentFields(area, config);
         errors = [...errors, ...collectionErrors];
     }
     return errors;
@@ -57,12 +59,12 @@ const validateFields = (config) => {
 /**
  *
  */
-const validateDocumentFields = (config) => {
+const validateDocumentFields = (documentConfig, config) => {
     const errors = [];
-    const isCollection = (config) => config.type === 'collection';
-    const isAuth = isCollection(config) && isAuthConfig(config);
+    const isCollection = (documentConfig) => documentConfig.type === 'collection';
+    const isAuth = isCollection(documentConfig) && isAuthConfig(documentConfig);
     const registeredBlocks = {};
-    const fieldsCompiled = config.fields.map((f) => f.compile());
+    const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
     if (isAuth) {
         const rolesField = fieldsCompiled
             .filter(isFormField)
@@ -73,28 +75,37 @@ const validateDocumentFields = (config) => {
             .filter(isFormField)
             .find((f) => f.name === 'email' && f.type === 'email');
         if (!rolesField)
-            errors.push(`Field roles is missing in collection ${config.slug}`);
-        if (!emailField && config.auth.type !== 'apiKey')
-            errors.push(`Field email is missing in collection ${config.slug}`);
+            errors.push(`Field roles is missing in collection ${documentConfig.slug}`);
+        if (!emailField && documentConfig.auth.type !== 'apiKey')
+            errors.push(`Field email is missing in collection ${documentConfig.slug}`);
         if (!nameField)
-            errors.push(`Field name is missing in collection ${config.slug}`);
+            errors.push(`Field name is missing in collection ${documentConfig.slug}`);
         if (!rolesField.many)
             errors.push(`Field roles must have "many" enabled : select('roles').options(...).many(), even with a single option`);
     }
     const validateBlockField = (fields, blockType) => {
         const reserved = ['path', 'type', 'ownerId', 'position', 'locale'];
         for (const key of reserved) {
-            if (fields.map((f) => f.name).filter((name) => name === key).length > 1) {
+            if (fields
+                .filter(isFormField)
+                .map((f) => f.name)
+                .filter((name) => name === key).length > 1) {
                 errors.push(`${key} is a reserved field in blocks (block ${blockType})`);
             }
         }
     };
-    const validateFormFields = (fields) => {
+    const validateRelationField = (field) => {
+        const collectionsSlugs = (config.collections || []).map((c) => c.slug);
+        if (!collectionsSlugs.includes(field.relationTo)) {
+            errors.push(`Relation field ${field.name} references unknown collection ${field.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
+        }
+    };
+    const validateFields = (fields) => {
         // Check for field name duplication at this level
-        const duplicates = hasDuplicates(fields.map((f) => f.name));
+        const duplicates = hasDuplicates(fields.filter(isFormField).map((f) => f.name));
         if (duplicates.length) {
             for (const duplicate of duplicates) {
-                errors.push(`Duplicate field '${duplicate}' in ${config.type} '${config.slug}'`);
+                errors.push(`Duplicate field '${duplicate}' in ${documentConfig.type} '${documentConfig.slug}'`);
             }
         }
         function validateFieldName(name) {
@@ -104,16 +115,33 @@ const validateDocumentFields = (config) => {
             // Check if string matches pattern and doesn't contain spaces or hyphens
             return pattern.test(name) && !name.includes('-') && !name.includes(' ');
         }
+        function validateTabs(field) {
+            const duplicates = hasDuplicates(field.tabs.map((t) => t.name));
+            if (duplicates.length) {
+                errors.push(`Dupplicate tab name ${duplicates} in ${documentConfig.slug}`);
+            }
+        }
         for (const field of fields) {
+            // Recursive check first into Tabs since tabs are not Formfields
+            if (isTabsFieldRaw(field)) {
+                validateTabs(field);
+                for (const tab of field.tabs) {
+                    validateFields(tab.fields);
+                }
+            }
+            // If field is not a Formfield eg. Separator then continue
+            if (!isFormField(field)) {
+                continue;
+            }
             // Check that a field wich has field._root = true is not localized
             if ('_root' in field && field._root && field.localized) {
-                errors.push(`Field ${field.name} of ${config.type} ${config.slug} with _root = true, can't be localized`);
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with _root = true, can't be localized`);
             }
             // Check for malformed field.name
             if (!validateFieldName(field.name)) {
-                errors.push(`Field ${field.name} of ${config.type} ${config.slug} should be camelCase`);
+                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
             }
-            // Recursive check into Blocks Groups and Tabs
+            // Recursive check into Blocks
             if (isBlocksFieldRaw(field)) {
                 for (const block of field.blocks) {
                     if (block.name in registeredBlocks) {
@@ -125,24 +153,25 @@ const validateDocumentFields = (config) => {
                     else {
                         registeredBlocks[block.name] = block;
                     }
-                    validateFormFields(block.fields.filter(isFormField));
+                    validateFields(block.fields.filter(isFormField));
                     validateBlockField(block.fields.filter(isFormField), block.name);
                 }
+                // Recursive check into Tree
             }
             else if (isTreeFieldRaw(field)) {
-                validateFormFields(field.fields.filter(isFormField));
-            }
-            else if (isTabsFieldRaw(field)) {
-                for (const tab of field.tabs) {
-                    validateFormFields(tab.fields.filter(isFormField));
-                }
+                validateFields(field.fields.filter(isFormField));
+                // Recursive check into Tabs
             }
             else if (isGroupFieldRaw(field)) {
-                validateFormFields(field.fields.filter(isFormField));
+                validateFields(field.fields.filter(isFormField));
+                // Check relation field
+            }
+            else if (isRelationField(field)) {
+                validateRelationField(field);
             }
         }
     };
-    validateFormFields(config.fields.map((f) => f.compile()).filter(isFormField));
+    validateFields(documentConfig.fields.map((f) => f.compile()));
     return errors;
 };
 const hasDatabase = (config) => {
@@ -163,6 +192,7 @@ function validateAuthCollections(config) {
     return errors;
 }
 function validate(config) {
+    logger.debug('Validating config...');
     const validateFunctions = [
         hasDuplicateSlug,
         hasUsersSlug,
@@ -174,9 +204,11 @@ function validate(config) {
         const errors = isValid(config);
         if (errors.length) {
             cache.clear();
-            throw new Error('Config error : ' + errors[0]);
+            errors.map((err) => logger.error(err));
+            return false;
         }
     }
+    logger.debug('Config is valid');
     return true;
 }
 export default validate;

package/dist/core/config/server/{write.js → write.server.js}

@@ -1,5 +1,5 @@
 import { flatten } from 'flat';
-import cache from '../../dev/cache/index.js';
+import cache from '../../dev/cache/index.server.js';
 const serializeValue = (value) => {
     if (value === null)
         return 'null';

package/dist/core/config/shared/augment-icons.d.ts

@@ -1,10 +1,9 @@
 import type { BuiltArea, BuiltCollection } from '../types.js';
 import type { Dic } from '../../../util/types.js';
-import type { IconProps } from '@lucide/svelte';
 import type { Component } from 'svelte';
 export declare const augmentIcons: <const T extends {
     collections?: BuiltCollection[];
     areas?: BuiltArea[];
 }>(config: T) => T & {
-    readonly icons: Dic<Component<IconProps, {}, string>>;
+    readonly icons: Dic<Component<import("@lucide/svelte").LucideProps, {}, string>>;
 };

package/dist/core/config/shared/get-staff-collection.d.ts

@@ -15,7 +15,7 @@ export declare const staffCollection: {
         type: string;
         roles: string[];
     };
-    icon: import("svelte").Component<import("@lucide/svelte").IconProps, {}, "">;
+    icon: import("svelte").Component<import("@lucide/svelte").LucideProps, {}, "">;
     fields: FieldBuilder<Field>[];
     access: Access;
 };

package/dist/core/config/shared/upload-directories.js

@@ -47,7 +47,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
             plural: `${collection.slug} directories`
         },
         icon: collection.icon,
-        asTitle: 'path',
+        asTitle: 'name',
         asThumbnail: collection.asThumbnail,
         panel: false
     };

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

@@ -168,12 +168,6 @@ export type VersionsConfig = {
     maxVersions?: number;
 };
 export type UrlDefinition<T extends BaseDoc = BaseDoc> = (document: T) => string;
-export type PrototypePanelConfig = {
-    /** Description for the collection/area, basically displayed on the dashboard */
-    description?: string;
-    /** Sidebar navigation group */
-    group?: string;
-};
 type PrototypeConfig<S extends string = string> = {
     slug: S;
     /** Document fields definition */
@@ -185,8 +179,6 @@ type PrototypeConfig<S extends string = string> = {
     access?: Access;
     /** If the document can be edited live, if enabled the url prop must be set also. */
     live?: boolean;
-    /** Panel configuration, set false to hide the area/collection from the panel */
-    panel?: false | PrototypePanelConfig;
 };
 export type UploadConfig = {
     /**
@@ -233,6 +225,17 @@ export type CollectionAuthConfig = ({
 }) & {
     roles?: (string | Option)[];
 };
+export type CollectionPanelConfig = false | {
+    /** Description for the collection/area, basically displayed on the dashboard */
+    description?: string;
+    /** Sidebar navigation group */
+    group?: string;
+    /** Dashboard settings */
+    dashboard?: {
+        layout?: 'rows' | 'grid';
+        maxEntries?: number;
+    } | false;
+};
 export type Collection<S> = {
     slug: S;
     /** The collection label */
@@ -247,6 +250,8 @@ export type Collection<S> = {
     nested?: boolean;
     /** Whether the collection support file upload */
     upload?: boolean | UploadConfig;
+    /** Panel configuration, set false to hide the collection from the panel */
+    panel?: CollectionPanelConfig;
 } & PrototypeConfig;
 export type Area<S> = PrototypeConfig & {
     slug: S;
@@ -255,6 +260,13 @@ export type Area<S> = PrototypeConfig & {
     $hooks?: AreaHooks<S extends keyof RegisterArea ? S : any>;
     /** The area label */
     label?: string;
+    /** Panel configuration, set false to hide the area from the panel */
+    panel?: false | {
+        /** Description for the collection/area, basically displayed on the dashboard */
+        description?: string;
+        /** Sidebar navigation group */
+        group?: string;
+    };
 };
 type NavigationConfig = {
     groups: Array<{

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

@@ -1 +1 @@
-export declare const polkaServer = "import polka from 'polka';\nimport serveStatic from 'serve-static';\nimport { handler } from './build/handler.js';\n\nconst serve = serveStatic('./static');\n\npolka()\n\t.use(serve)\n\t.use(handler)\n\t.listen(3000, () => {\n\t\tconsole.log(\"server running\");\n\t});\n";
+export declare const polkaServer = "import polka from 'polka';\nimport serveStatic from 'serve-static';\nimport { handler } from './build/handler.js';\n\nconst serve = serveStatic('./static');\n\nconst port = process.env.PORT || 3000;\nconst host = process.env.HOST || '127.0.0.1';\n\npolka()\n\t.use(serve)\n\t.use(handler)\n\t.listen(port, host, () => {\n\t\tconsole.log(`server running on ${host}:${port}`);\n\t});\n";

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

@@ -4,10 +4,13 @@ import { handler } from './build/handler.js';
 
 const serve = serveStatic('./static');
 
+const port = process.env.PORT || 3000;
+const host = process.env.HOST || '127.0.0.1';
+
 polka()
 	.use(serve)
 	.use(handler)
-	.listen(3000, () => {
-		console.log("server running");
+	.listen(port, host, () => {
+		console.log(\`server running on \${host}:\${port}\`);
 	});
 `;

package/dist/core/dev/cli/generate/{index.js → index.server.js}

@@ -1,5 +1,4 @@
-import cache from '../../cache/index.js';
-import { sanitize } from '../../generate/sanitize/index.js';
+import { sanitize } from '../../generate/sanitize/index.server.js';
 import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
 import { logger } from '../../../logger/index.server.js';
 import { trycatch } from '../../../../util/function.js';
@@ -62,18 +61,23 @@ export const generate = async (args) => {
         ensureUserConfigExist();
         await sanitizeConfig();
         const importPathJS = ensureGeneratedConfig();
-        logger.info('Generate');
+        logger.info('Starting vite server...');
         const vite = await createServer();
-        await vite.ssrLoadModule(importPathJS);
-        while (cache.get('.init')) {
-            await new Promise((resolve) => setTimeout(resolve, 200));
+        try {
+            const mod = await vite.ssrLoadModule(importPathJS);
+            // The generated 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 failures (e.g. config validation).
+            await mod.default;
+            logger.info('[✓] Generation completed successfully');
+        }
+        finally {
+            await vite.close();
         }
-        await vite.close();
-        logger.info('[✓] Generation completed successfully');
     }
     const [error] = await trycatch(run);
     if (error) {
-        logger.error('Error during generation:', error);
+        logger.error('[✗] Error during generation:', error);
         throw error;
     }
 };

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

@@ -8,7 +8,7 @@ program
     .option('-f, --force', 'Force init with default package name', false)
     .option('-s, --skip-install', 'Do not install dependencies', false)
     .action(async (args) => {
-    const init = await import('./init/index.js').then((m) => m.init);
+    const init = await import('./init/index.server.js').then((m) => m.init);
     init(args);
 });
 program
@@ -22,16 +22,21 @@ program
     .command('clear')
     .option('-f, --force', 'Force clear without prompt', false)
     .action(async (args) => {
-    const clear = await import('./clear/index.js').then((m) => m.clear);
+    const clear = await import('./clear/index.server.js').then((m) => m.clear);
     clear(args);
 });
 program
     .command('generate')
     .option('-f, --force', 'Force generation, ignore cache, overwrite routes', false)
     .action(async (args) => {
-    const generate = await import('./generate/index.js').then((m) => m.generate);
-    generate({
-        force: args.force
-    });
+    const generate = await import('./generate/index.server.js').then((m) => m.generate);
+    try {
+        await generate({
+            force: args.force
+        });
+    }
+    catch {
+        process.exitCode = 1;
+    }
 });
 program.parse(process.argv);

package/dist/core/dev/cli/init/{index.js → index.server.js}

@@ -1,15 +1,19 @@
 import { logger } from '../../../logger/index.server.js';
 import { randomId } from '../../../../util/random.js';
 import { isValidSlug, slugify } from '../../../../util/string.js';
+import { generate as generateCode } from '@babel/generator';
+import * as t from '@babel/types';
+import { babelParse } from 'ast-kit';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 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 { generate } from '../generate/index.js';
+import { generate } from '../generate/index.server.js';
 import { prompt } from '../util.server.js';
-import { getPackageInfoByKey } from './getPackageName.js';
-import { installDependencies } from './packageManagerUtil.js';
+import { getPackageInfoByKey } from './get-package-info.server.js';
+import { installDependencies } from './package-manager-util.server.js';
 import * as templates from './templates.js';
 const PACKAGE = 'rimecms';
 const root = process.cwd();
@@ -104,33 +108,72 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
     }
     function configureVite() {
         const configPath = path.resolve(root, 'vite.config.ts');
-        if (!existsSync(configPath)) {
+        if (!fs.existsSync(configPath)) {
             throw new Error("Can't find vite configuration file");
         }
-        const content = readFileSync(configPath, 'utf-8');
-        if (!content.includes('rime()')) {
-            // Add import
-            const newContent = content.replace(/(import .* from .*;\n?)/, `$1import { rime } from '${PACKAGE}/vite';\n`);
-            // Add plugin to the list - ensure it's after sveltekit()
-            const updatedContent = newContent.replace(/plugins:\s*\[([\s\S]*?)\]/, (match, plugins) => {
-                // Check if sveltekit() is in the plugins list
-                if (plugins.includes('sveltekit()')) {
-                    // Add rime() after sveltekit()
-                    return plugins.includes('sveltekit()')
-                        ? match.replace('sveltekit()', 'sveltekit(), rime()')
-                        : `plugins: [${plugins}, rime()]`;
-                }
-                else {
-                    // If sveltekit() isn't found, add rime() at the end
-                    return `plugins: [${plugins}, rime()]`;
-                }
-            });
-            writeFileSync(configPath, updatedContent);
-            logger.info('[✓] Vite plugin added');
+        let content = fs.readFileSync(configPath, 'utf-8');
+        content = content.replace("from '@sveltejs/adapter-auto'", "from '@sveltejs/adapter-node'");
+        const program = babelParse(content, configPath); // t.Program
+        const programBody = program.body;
+        const configObject = findSvelteConfigObject(programBody);
+        if (!configObject) {
+            throw new Error("Couldn't find the Vite config object (defineConfig({...}) or export default {...})");
+        }
+        const pluginsProp = configObject.properties.find((p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === 'plugins');
+        if (!pluginsProp || !t.isArrayExpression(pluginsProp.value)) {
+            throw new Error("Couldn't find a `plugins: [...]` array in the Vite config object");
+        }
+        const pluginsArray = pluginsProp.value;
+        const alreadyPresent = pluginsArray.elements.some((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'rime');
+        if (alreadyPresent) {
+            logger.info('[✓] Vite plugin already present (skip)');
+            return;
+        }
+        const hasImport = programBody.some((node) => t.isImportDeclaration(node) &&
+            node.source.value === `${PACKAGE}/vite` &&
+            node.specifiers.some((s) => t.isImportSpecifier(s) && t.isIdentifier(s.imported) && s.imported.name === 'rime'));
+        if (!hasImport) {
+            const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('rime'), t.identifier('rime'))], t.stringLiteral(`${PACKAGE}/vite`));
+            programBody.unshift(importDecl);
+        }
+        const rimeCall = t.callExpression(t.identifier('rime'), []);
+        const sveltekitIndex = pluginsArray.elements.findIndex((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'sveltekit');
+        if (sveltekitIndex !== -1) {
+            pluginsArray.elements.splice(sveltekitIndex + 1, 0, rimeCall);
         }
         else {
-            logger.info('[✓] Vite plugin already present (skip)');
+            pluginsArray.elements.push(rimeCall);
+        }
+        const file = t.file(program);
+        const { code } = generateCode(file, {}, content);
+        fs.writeFileSync(configPath, code);
+        logger.info('[✓] Vite plugin added');
+    }
+    function findSvelteConfigObject(body) {
+        for (const node of body) {
+            if (t.isExpressionStatement(node) &&
+                t.isCallExpression(node.expression) &&
+                t.isIdentifier(node.expression.callee) &&
+                node.expression.callee.name === 'defineConfig') {
+                const arg = node.expression.arguments[0];
+                if (t.isObjectExpression(arg))
+                    return arg;
+            }
+            if (t.isExportDefaultDeclaration(node)) {
+                const decl = node.declaration;
+                if (t.isCallExpression(decl) &&
+                    t.isIdentifier(decl.callee) &&
+                    decl.callee.name === 'defineConfig') {
+                    const arg = decl.arguments[0];
+                    if (t.isObjectExpression(arg))
+                        return arg;
+                }
+                if (t.isObjectExpression(decl)) {
+                    return decl;
+                }
+            }
         }
+        return null;
     }
     function setHooks() {
         const hooksPath = path.join(root, 'src', 'hooks.server.ts');

package/dist/core/dev/cli/init/{packageManagerUtil.js → package-manager-util.server.js}

@@ -11,23 +11,23 @@ const packageManagersMap = {
 };
 const packageManagerConfigs = {
     yarn: {
-        command: 'yarn add -D drizzle-kit'
+        command: 'echo "yarn is not supported, please use pnpm or npm" && exit 1'
     },
     pnpm: {
-        command: 'pnpm add -D drizzle-kit && pnpm add drizzle-orm @lucide/svelte sharp',
+        command: 'pnpm add -D drizzle-kit && pnpm add -D @sveltejs/adapter-node && pnpm add drizzle-orm @lucide/svelte sharp',
         preInstall: updatePackageJsonForPnpm,
         postInstall: () => {
             execSync('pnpm rebuild');
         }
     },
     bun: {
-        command: 'bun add -D drizzle-kit'
+        command: 'bun add -D drizzle-kit && bun add -D @sveltejs/adapter-node && bun add drizzle-orm @lucide/svelte sharp'
     },
     npm: {
-        command: 'npm install -D drizzle-kit'
+        command: 'npm install -D drizzle-kit && npm install -D @sveltejs/adapter-node && npm install drizzle-orm @lucide/svelte sharp'
     },
     deno: {
-        command: 'deno install -D npm:drizzle-kit && deno install --allow-scripts=npm:sharp'
+        command: 'echo "deno is not supported, please use pnpm or npm" && exit 1'
     }
 };
 export function getPackageManager() {

package/dist/core/dev/generate/routes/{area.d.ts → area.server.d.ts}

@@ -1,4 +1,4 @@
-import { type Routes } from './util.js';
+import { type Routes } from './util.server.js';
 /**
  * Area routes dictionary defining route patterns and their corresponding templates
  */