rimecms 0.33.0 → 1.0.0

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

@@ -1286,7 +1286,7 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
                         $Infer: {
                             body: {
                                 userId: string;
-                                role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                                role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
                             };
                         };
                     };
@@ -1375,7 +1375,7 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
                                 email: string;
                                 password?: string | undefined;
                                 name: string;
-                                role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                                role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
                                 data?: Record<string, any> | undefined;
                             };
                         };
@@ -1999,7 +1999,7 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
                                 };
                             } & {
                                 userId?: string | undefined;
-                                role?: "user" | "admin" | "staff" | undefined;
+                                role?: "user" | "staff" | "admin" | undefined;
                             };
                         };
                     };
@@ -3357,7 +3357,7 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
                         $Infer: {
                             body: {
                                 userId: string;
-                                role: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[];
+                                role: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[];
                             };
                         };
                     };
@@ -3446,7 +3446,7 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
                                 email: string;
                                 password?: string | undefined;
                                 name: string;
-                                role?: "user" | "admin" | "staff" | ("user" | "admin" | "staff")[] | undefined;
+                                role?: "user" | "staff" | "admin" | ("user" | "staff" | "admin")[] | undefined;
                                 data?: Record<string, any> | undefined;
                             };
                         };
@@ -4070,7 +4070,7 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
                                 };
                             } & {
                                 userId?: string | undefined;
-                                role?: "user" | "admin" | "staff" | undefined;
+                                role?: "user" | "staff" | "admin" | undefined;
                             };
                         };
                     };

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

@@ -20,7 +20,7 @@ import type { IconProps } from '@lucide/svelte';
 import type { RequestEvent, RequestHandler } from '@sveltejs/kit';
 import type { Component } from 'svelte';
 import type { FieldBuilder } from '../fields/builders/index.js';
-import type { DocType } from '../prototype/types.js';
+import type { DocType, GenericDoc } from '../prototype/types.js';
 /**
  * What an author writes.
  *
@@ -38,6 +38,8 @@ export interface Config {
     /** If config.siteUrl is defined, a preview button is added
       on the panel dahsboard, pointing to this url  */
     siteUrl?: string;
+    /** The name at the top of the panel's sidebar. Without it, the host of `siteUrl`, then "rime". */
+    siteName?: string;
     /**
      * Database adapter
      * @example
@@ -141,6 +143,27 @@ type PrototypeConfig<S extends string = string> = {
     /** If the document can be edited live, if enabled the url prop must be set also. */
     live?: boolean;
 };
+/**
+ * What `$url` is given to format a document's url.
+ *
+ * ```ts
+ * $url: ({ path, locale, doc }) => `/${locale}/${path.join('/')}`
+ * // path ['services', 'web'], slug 'web', locale 'en' -> '/en/services/web'
+ * ```
+ *
+ * A pure, synchronous function of these: the url is stored when a page is saved or moved, and
+ * found by, so it has to come from nothing else. A relative url is made absolute against
+ * `PUBLIC_RIME_URL`.
+ */
+export type UrlArgs<Doc> = {
+    /** The slugs from the top page down to this one; empty for an area. */
+    path: string[];
+    /** This page's own slug; empty for an area. */
+    slug: string;
+    /** The locale the url is for; empty when the config has no localization. */
+    locale: string;
+    doc: Doc;
+};
 export type Collection<S> = {
     slug: S;
     /** The collection label */
@@ -149,8 +172,11 @@ export type Collection<S> = {
     auth?: boolean | CollectionAuthConfig;
     /** Operation hooks */
     $hooks?: CollectionHooks<S extends keyof RegisterCollection ? S : any>;
-    /** A function to generate the document URL */
-    $url?: (doc: S extends keyof RegisterCollection ? RegisterCollection[S] : any) => string;
+    /**
+     * Formats a document's url from its address. With it, each page gets a built-in slug, an address
+     * per locale, and `url`, `_urlPath`, `_slug` on its documents. See `UrlArgs`.
+     */
+    $url?: (args: UrlArgs<S extends keyof RegisterCollection ? RegisterCollection[S] : any>) => string;
     /** Whether a document can have children/parent */
     nested?: boolean;
     /** Whether the collection support file upload */
@@ -160,8 +186,8 @@ export type Collection<S> = {
 } & PrototypeConfig;
 export type Area<S> = PrototypeConfig & {
     slug: S;
-    /** A function to generate the document URL */
-    $url?: (doc: S extends keyof RegisterArea ? RegisterArea[S] : any) => string;
+    /** Formats the area's url, on read: `path` and `slug` are empty. See `UrlArgs`. */
+    $url?: (args: UrlArgs<S extends keyof RegisterArea ? RegisterArea[S] : any>) => string;
     $hooks?: AreaHooks<S extends keyof RegisterArea ? S : any>;
     /** The area label */
     label?: string;
@@ -176,6 +202,11 @@ export type Area<S> = PrototypeConfig & {
 export type BuiltCollection = Omit<Collection<string>, 'icon' | 'versions' | 'upload' | 'auth'> & {
     slug: CollectionSlug;
     type: 'collection';
+    /**
+     * A document of this config's shape with every default applied, and no id — see
+     * `prototype/blank.ts`, which every config carries as this method.
+     */
+    blank(event?: RequestEvent): GenericDoc;
     /** Make fields mandatory */
     fields: FieldBuilder<Field>[];
     /** The kebab-case version of the slug for urls */
@@ -230,6 +261,11 @@ export type BuiltAreaClient = BuiltArea;
 export type BuiltArea = Omit<Area<string>, 'versions'> & {
     slug: AreaSlug;
     type: 'area';
+    /**
+     * A document of this config's shape with every default applied, and no id — see
+     * `prototype/blank.ts`, which every config carries as this method.
+     */
+    blank(event?: RequestEvent): GenericDoc;
     /** Make fields mandatory */
     fields: FieldBuilder<Field>[];
     /** The kebab-case version of the slug for urls */
@@ -266,6 +302,8 @@ export type BuiltConfig = {
     $database: string;
     /** The database location */
     siteUrl?: string;
+    /** The name at the top of the panel's sidebar. */
+    siteName?: string;
     /** Define wich language the cms support */
     localization?: LocalizationConfig;
     icons: Record<string, any>;

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

@@ -4,10 +4,8 @@ import cache from '../dev/cache.server.js';
 import { isFormField } from '../fields/util.js';
 import { logger } from '../logger.server.js';
 import { BlocksBuilder } from '../../fields/blocks/index.js';
-import { GroupFieldBuilder } from '../../fields/group/index.js';
 import { RelationFieldBuilder } from '../../fields/relation/index.js';
 import { TabsBuilder } from '../../fields/tabs/index.js';
-import { TreeBuilder } from '../../fields/tree/index.js';
 import { prototypeKebab } from '../prototype/naming.js';
 import { isCamelCase } from '../../util/string.js';
 function hasDuplicates(arr) {
@@ -92,10 +90,7 @@ const validateDocumentFields = (documentConfig, config) => {
     const validateBlockField = (fields, blockType) => {
         const reserved = ['path', 'type', 'ownerId', 'position', 'locale'];
         for (const key of reserved) {
-            if (fields
-                .filter(isFormField)
-                .map((f) => f.name)
-                .filter((name) => name === key).length > 1) {
+            if (fields.filter((field) => field.name === key).length > 1) {
                 errors.push(`${key} is a reserved field in blocks (block ${blockType})`);
             }
         }
@@ -133,57 +128,45 @@ const validateDocumentFields = (documentConfig, config) => {
             }
         }
         for (const field of fields) {
-            // Recursive check first into Tabs since tabs are not Formfields
-            if (field instanceof TabsBuilder) {
+            // Tabs are not form fields, so their own rule runs before the form-field checks.
+            if (field instanceof TabsBuilder)
                 validateTabs(field);
-                for (const tab of field.get.tabs) {
-                    validateFields(tab.get.fields);
+            if (isFormField(field)) {
+                // A `$root()` field sits on the base row, which has no locales branch.
+                if (field.get.root && field.get.localized) {
+                    errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with $root(), can't be localized`);
                 }
-            }
-            // If field is not a Formfield eg. Separator then continue
-            if (!isFormField(field)) {
-                continue;
-            }
-            // A `$root()` field sits on the base row, which has no locales branch.
-            if (field.get.root && field.get.localized) {
-                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with $root(), can't be localized`);
-            }
-            // A resolved reference is joined from a column of the row; a localized column is on the
-            // locales branch, where no join reaches it.
-            if (field._references?.resolve && field.get.localized) {
-                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with a resolved reference, can't be localized`);
-            }
-            // Check for malformed field.name
-            if (!validateFieldName(field.name)) {
-                errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
-            }
-            // Recursive check into Blocks
-            if (field instanceof BlocksBuilder) {
-                for (const block of field.get.blocks) {
-                    if (block.name in registeredBlocks) {
-                        const blockDefinedButDiffer = JSON.stringify(registeredBlocks[block.name]) !== JSON.stringify(block);
-                        if (blockDefinedButDiffer) {
-                            errors.push(`Each block with same name should be identique (block ${block.name})`);
+                // A resolved reference is joined from a column of the row; a localized column is on the
+                // locales branch, where no join reaches it.
+                if (field._references?.resolve && field.get.localized) {
+                    errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with a resolved reference, can't be localized`);
+                }
+                // Check for malformed field.name
+                if (!validateFieldName(field.name)) {
+                    errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
+                }
+                // A blocks rule, not a walk: it compares whole block builders, which a node does not carry.
+                if (field instanceof BlocksBuilder) {
+                    for (const block of field.get.blocks) {
+                        if (block.name in registeredBlocks) {
+                            const blockDefinedButDiffer = JSON.stringify(registeredBlocks[block.name]) !== JSON.stringify(block);
+                            if (blockDefinedButDiffer) {
+                                errors.push(`Each block with same name should be identique (block ${block.name})`);
+                            }
                         }
+                        else {
+                            registeredBlocks[block.name] = block;
+                        }
+                        validateBlockField(block.get.fields, block.name);
                     }
-                    else {
-                        registeredBlocks[block.name] = block;
-                    }
-                    validateFields(block.get.fields.filter(isFormField));
-                    validateBlockField(block.get.fields.filter(isFormField), block.name);
                 }
-                // Recursive check into Tree
-            }
-            else if (field instanceof TreeBuilder) {
-                validateFields(field.get.fields.filter(isFormField));
-                // Recursive check into Tabs
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                validateFields(field.get.fields.filter(isFormField));
-                // Check relation field
+                else if (field instanceof RelationFieldBuilder) {
+                    validateRelationField(field);
+                }
             }
-            else if (field instanceof RelationFieldBuilder) {
-                validateRelationField(field);
+            // Every block type, every tab, a group's and a tree row's fields: one level each.
+            for (const node of field.use.nodes()) {
+                validateFields(node.fields);
             }
         }
     };

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

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import { spawnSync } from 'child_process';
 import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'fs';
 import { getInvokingPackageManager } from '../util/package-manager.server.js';
+import { usesBunScripts } from '../util/package.server.js';
 import { envProduction, nodeServer } from '../templates/build.js';
 const installCommands = {
     pnpm: {
@@ -15,15 +16,28 @@ const installCommands = {
         addDeps: 'npm install sharp serve-static',
         prodInstall: 'npm install --omit=dev',
         runEnv: 'npx rime env'
+    },
+    bun: {
+        addDeps: 'bun add sharp serve-static',
+        prodInstall: 'bun install --production',
+        runEnv: 'bunx rime env'
     }
 };
 export const build = (args) => {
+    const bun = usesBunScripts();
     // Delete app folder if it exists
     if (existsSync('./app')) {
         rmSync('./app', { recursive: true, force: true });
     }
     // Build
-    spawnSync('./node_modules/.bin/vite', ['build'], { stdio: 'inherit' });
+    // A Bun app builds on Bun: `bun --bun` runs vite, and anything the build imports, on Bun
+    // rather than on its bin's Node shebang
+    if (bun) {
+        spawnSync('bun', ['--bun', './node_modules/.bin/vite', 'build'], { stdio: 'inherit' });
+    }
+    else {
+        spawnSync('./node_modules/.bin/vite', ['build'], { stdio: 'inherit' });
+    }
     console.log('');
     // Create app directory
     mkdirSync('./app', { recursive: true });
@@ -56,15 +70,16 @@ export const build = (args) => {
     console.log('## Next steps :');
     console.log('');
     console.log('    cd ./app');
-    const pm = getInvokingPackageManager() === 'pnpm' ? 'pnpm' : 'npm';
+    const pm = bun ? 'bun' : getInvokingPackageManager() === 'pnpm' ? 'pnpm' : 'npm';
+    console.log('    ' + installCommands[pm].addDeps);
+    console.log('    ' + installCommands[pm].prodInstall);
+    // After the install: before it, `npx rime`/`bunx rime` fetch the unrelated `rime` package
     if (!args.withEnv) {
         console.log('    ' +
             installCommands[pm].runEnv +
             ' ' +
-            chalk.dim(`# next time run \`${pm === 'pnpm' ? 'pnpm' : 'npx'} rime build -e\` to generate the .env file automatically`));
+            chalk.dim(`# next time run \`${{ pnpm: 'pnpm', npm: 'npx', bun: 'bunx' }[pm]} rime build -e\` to generate the .env file automatically`));
     }
-    console.log('    ' + installCommands[pm].addDeps);
-    console.log('    ' + installCommands[pm].prodInstall);
     console.log('');
-    console.log('    node --env-file=.env index.js');
+    console.log(bun ? '    bun index.js' : '    node --env-file=.env index.js');
 };

package/dist/core/dev/cli/commands/init.server.d.ts

@@ -2,6 +2,7 @@ type Args = {
     force?: boolean;
     skipInstall?: boolean;
     name?: string;
+    bun?: boolean;
 };
-export declare const init: ({ force, name: incomingName, skipInstall }: Args) => Promise<void>;
+export declare const init: ({ force, name: incomingName, skipInstall, bun }: Args) => Promise<void>;
 export {};

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

@@ -1,10 +1,12 @@
 import { logger } from '../../../logger.server.js';
 import { PANEL_ROUTE } from '../../../routes/constants.server.js';
+import { trycatchSync } from '../../../../util/function.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, getLang } from 'ast-kit';
+import { execSync } from 'child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { cp, mkdir } from 'fs/promises';
 import fs from 'node:fs';
@@ -12,14 +14,15 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { CONFIG_DIR, OUTPUT_DIR } from '../../constants.server.js';
 import * as templates from '../templates/init.js';
-import { installDependencies } from '../util/package-manager.server.js';
-import { getPackageInfoByKey } from '../util/package.server.js';
+import { installDependencies, SVELTEKIT_ADAPTER } from '../util/package-manager.server.js';
+import { getPackageInfoByKey, MIN_BUN, setBunScripts } from '../util/package.server.js';
 import { prompt } from '../util/prompt.server.js';
 import { generate } from './generate.server.js';
 const PACKAGE = 'rimecms';
 const root = process.cwd();
-export const init = async ({ force, name: incomingName, skipInstall }) => {
+export const init = async ({ force, name: incomingName, skipInstall, bun }) => {
     const packageName = getPackageInfoByKey('name');
+    const driver = bun ? 'bun' : 'libsql';
     function setEnv() {
         const envPath = path.resolve(root, '.env');
         // Define variables with their update behavior
@@ -62,7 +65,7 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
             if (!existsSync(configDirPath)) {
                 mkdirSync(configDirPath);
             }
-            writeFileSync(configPath, templates.defaultConfig(name.toString()));
+            writeFileSync(configPath, templates.defaultConfig(name.toString(), driver));
             logger.info(`[✓] Config created at ${configDirPath}/rime.config.server.ts`);
         }
         else {
@@ -120,13 +123,32 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
             ? '[✓] Drizzle config schema path updated'
             : '[✓] Drizzle config already exists (skip)');
     }
+    function setBun() {
+        if (!bun)
+            return;
+        // init itself runs on Node (the bin's shebang): ask the bun on PATH
+        const version = trycatchSync(() => execSync('bun --version', { encoding: 'utf-8' }).trim())[1];
+        const [major, minor] = (version ?? '0.0').split('.').map(Number);
+        const [minMajor, minMinor] = MIN_BUN.split('.').map(Number);
+        if (major < minMajor || (major === minMajor && minor < minMinor)) {
+            logger.warn(`Bun ${version ?? 'not found'}: the Bun pack needs >= ${MIN_BUN} (older versions boot dev ~2x slower). Run \`bun upgrade\`.`);
+        }
+        logger.info(setBunScripts()
+            ? '[✓] package.json scripts run vite with bun --bun'
+            : '[✓] package.json scripts already set (skip)');
+    }
+    function setAdapter() {
+        const patched = templates.setSvelteKitAdapter(root);
+        logger.info(patched.length
+            ? `[✓] SvelteKit adapter set to ${SVELTEKIT_ADAPTER} in ${patched.join(', ')}`
+            : `[✓] SvelteKit adapter already set (skip)`);
+    }
     function configureVite() {
         const configPath = path.resolve(root, 'vite.config.ts');
         if (!fs.existsSync(configPath)) {
             throw new Error("Can't find vite configuration file");
         }
-        let content = fs.readFileSync(configPath, 'utf-8');
-        content = content.replace("from '@sveltejs/adapter-auto'", "from '@sveltejs/adapter-node'");
+        const content = fs.readFileSync(configPath, 'utf-8');
         const program = babelParse(content, getLang(configPath));
         const programBody = program.body;
         const configObject = findSvelteConfigObject(programBody);
@@ -209,6 +231,8 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         setConfig(name);
         setDatabase();
         setDrizzle(name);
+        setBun();
+        setAdapter();
         configureVite();
         await copyAssets();
         !skipInstall && installDependencies();
@@ -233,6 +257,8 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
         setConfig(name);
         setDatabase();
         setDrizzle(name);
+        setBun();
+        setAdapter();
         configureVite();
         await copyAssets();
         !skipInstall && installDependencies();

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

@@ -11,6 +11,7 @@ program
     .option('-n, --name <name>', 'Will be the database name')
     .option('-f, --force', 'Force init with default package name', false)
     .option('-s, --skip-install', 'Do not install dependencies', false)
+    .option('-b, --bun', 'Bun pack: bun:sqlite driver, bun --bun scripts', false)
     .action(async (args) => {
     const init = await import('./commands/init.server.js').then((m) => m.init);
     init(args);

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

@@ -1,5 +1,5 @@
 export declare const env: () => string;
-export declare const defaultConfig: (name: string) => string;
+export declare const defaultConfig: (name: string, driver?: "libsql" | "bun") => string;
 export declare const drizzleConfig: (name: string) => string;
 export declare const hooks: () => string;
 /** Writes src/hooks.server.ts if missing. If it already exists, patches only the config
@@ -16,3 +16,8 @@ export declare function regenerateHooks(root?: string): boolean;
  * 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;
+/** Swaps adapter-auto for adapter-node, wherever the app declares it: `vite.config.ts` in
+ * current sv templates, `svelte.config.js` in older ones. adapter-auto produces nothing for a
+ * plain Node or Bun server. Any other adapter is the app's choice and left alone. Returns the
+ * files it patched. */
+export declare function setSvelteKitAdapter(root: string): string[];

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

@@ -3,6 +3,7 @@ import { randomId } from '../../../../util/random.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { CONFIG_DIR, GENERATED_DIR, configImportPaths } from '../../constants.server.js';
+import { SVELTEKIT_ADAPTER } from '../util/package-manager.server.js';
 const PACKAGE = 'rimecms';
 export const env = () => `BETTER_AUTH_SECRET=${randomId(32)}
 PUBLIC_RIME_URL=http://localhost:5173
@@ -26,7 +27,7 @@ RIME_LOG_LEVEL=TRACE
 RIME_LOG_TO_FILE=true
 RIME_LOG_TO_FILE_MAX_DAYS=1
 `;
-export const defaultConfig = (name) => `
+export const defaultConfig = (name, driver = 'libsql') => `
 import { Collection, rime } from '$rime/config';
 import { text } from '${PACKAGE}/fields';
 import { adapterSqlite } from '${PACKAGE}/adapter-sqlite';
@@ -43,7 +44,7 @@ const Medias = Collection.create('medias', {
 });
 
 export default rime({
-  $adapter: adapterSqlite('${name}.sqlite'),
+  $adapter: adapterSqlite('${name}.sqlite'${driver === 'bun' ? ", { driver: 'bun' }" : ''}),
   collections: [Pages, Medias]
 });
 `;
@@ -115,3 +116,30 @@ export function regenerateDrizzleConfig(root = process.cwd()) {
     }
     return false;
 }
+const ADAPTER_CONFIG_FILES = [
+    'vite.config.ts',
+    'vite.config.js',
+    'svelte.config.js',
+    'svelte.config.ts',
+    'svelte.config.mjs'
+];
+/** Swaps adapter-auto for adapter-node, wherever the app declares it: `vite.config.ts` in
+ * current sv templates, `svelte.config.js` in older ones. adapter-auto produces nothing for a
+ * plain Node or Bun server. Any other adapter is the app's choice and left alone. Returns the
+ * files it patched. */
+export function setSvelteKitAdapter(root) {
+    const pattern = /from\s*(['"])@sveltejs\/adapter-auto\1/g;
+    const patched = [];
+    for (const file of ADAPTER_CONFIG_FILES) {
+        const configPath = path.join(root, file);
+        if (!existsSync(configPath))
+            continue;
+        const content = readFileSync(configPath, 'utf-8');
+        const next = content.replace(pattern, (_, quote) => `from ${quote}${SVELTEKIT_ADAPTER}${quote}`);
+        if (next !== content) {
+            writeFileSync(configPath, next);
+            patched.push(file);
+        }
+    }
+    return patched;
+}

package/dist/core/dev/cli/util/package-manager.server.d.ts

@@ -1,4 +1,5 @@
 export type PackageManagerName = 'yarn' | 'pnpm' | 'bun' | 'npm' | 'deno';
+export declare const SVELTEKIT_ADAPTER = "@sveltejs/adapter-node";
 export declare function getPackageManager(): PackageManagerName;
 /**
  * Detects the package manager used to invoke the currently running command

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

@@ -14,26 +14,28 @@ const packageManagersMap = {
 // installed is the split that made every sign-in fail when better-auth did the same thing.
 const DRIZZLE = '1.0.0-rc.4';
 const deps = [`drizzle-orm@${DRIZZLE}`, '@libsql/client', '@lucide/svelte', 'sharp'];
-const devDeps = ['@sveltejs/adapter-node', `drizzle-kit@${DRIZZLE}`];
+// Both packs build with adapter-node: the Bun pack runs the same server on Bun
+export const SVELTEKIT_ADAPTER = '@sveltejs/adapter-node';
+const devDeps = [SVELTEKIT_ADAPTER, `drizzle-kit@${DRIZZLE}`];
 const packageManagerConfigs = {
     yarn: {
-        command: 'echo "yarn is not supported, please use pnpm or npm" && exit 1'
+        command: () => 'echo "yarn is not supported, please use pnpm or npm" && exit 1'
     },
     pnpm: {
-        command: `pnpm add -D ${devDeps.join(' ')} && pnpm add ${deps.join(' ')}`,
+        command: (devDeps) => `pnpm add -D ${devDeps.join(' ')} && pnpm add ${deps.join(' ')}`,
         preInstall: configurePnpm,
         postInstall: () => {
             execSync('pnpm rebuild');
         }
     },
     bun: {
-        command: `bun add -D ${devDeps.join(' ')} && bun add ${deps.join(' ')}`
+        command: (devDeps) => `bun add -D ${devDeps.join(' ')} && bun add ${deps.join(' ')}`
     },
     npm: {
-        command: `npm install -D ${devDeps.join(' ')} && npm install ${deps.join(' ')}`
+        command: (devDeps) => `npm install -D ${devDeps.join(' ')} && npm install ${deps.join(' ')}`
     },
     deno: {
-        command: 'echo "deno is not supported, please use pnpm or npm" && exit 1'
+        command: () => 'echo "deno is not supported, please use pnpm or npm" && exit 1'
     }
 };
 export function getPackageManager() {
@@ -69,8 +71,9 @@ export function installDependencies() {
     // Pre installation hooks
     config.preInstall?.();
     // Main installation
-    logger.info('exec : ' + config.command);
-    execSync(config.command);
+    const command = config.command(devDeps);
+    logger.info('exec : ' + command);
+    execSync(command);
     // Post installation hooks
     config.postInstall?.();
 }

package/dist/core/dev/cli/util/package.server.d.ts

@@ -1 +1,10 @@
 export declare function getPackageInfoByKey(key: string): string;
+/** Below it, JavaScriptCore's slow lookbehind regexes (Vite's wasm filters) double dev boot. */
+export declare const MIN_BUN = "1.4";
+/**
+ * Prefixes the app's vite scripts with `bun --bun`, so vite (and `bun:sqlite`) run on Bun
+ * rather than on the Node its bin's shebang asks for. Returns whether it wrote anything.
+ */
+export declare function setBunScripts(): boolean;
+/** Whether `rime init --bun` set this app up — its vite scripts are what `rime build` reads back. */
+export declare function usesBunScripts(): boolean;

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

@@ -15,3 +15,46 @@ export function getPackageInfoByKey(key) {
         return '';
     }
 }
+const BUN_PREFIX = 'bun --bun ';
+/** Below it, JavaScriptCore's slow lookbehind regexes (Vite's wasm filters) double dev boot. */
+export const MIN_BUN = '1.4';
+const VITE_SCRIPTS = ['dev', 'build', 'preview'];
+function readPackageJson() {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const raw = fs.readFileSync(packageJsonPath, 'utf-8');
+    // Keep the file's own indentation (sv writes tabs)
+    const indent = raw.match(/^[ \t]+/m)?.[0] ?? '  ';
+    return { path: packageJsonPath, json: JSON.parse(raw), indent };
+}
+/**
+ * Prefixes the app's vite scripts with `bun --bun`, so vite (and `bun:sqlite`) run on Bun
+ * rather than on the Node its bin's shebang asks for. Returns whether it wrote anything.
+ */
+export function setBunScripts() {
+    const { path: packageJsonPath, json, indent } = readPackageJson();
+    let changed = false;
+    for (const key of VITE_SCRIPTS) {
+        const script = json.scripts?.[key];
+        if (typeof script === 'string' && script.startsWith('vite ')) {
+            json.scripts[key] = BUN_PREFIX + script;
+            changed = true;
+        }
+    }
+    if (!json.engines?.bun) {
+        json.engines = { ...json.engines, bun: `>=${MIN_BUN}` };
+        changed = true;
+    }
+    if (changed)
+        fs.writeFileSync(packageJsonPath, JSON.stringify(json, null, indent) + '\n');
+    return changed;
+}
+/** Whether `rime init --bun` set this app up — its vite scripts are what `rime build` reads back. */
+export function usesBunScripts() {
+    try {
+        const { json } = readPackageJson();
+        return VITE_SCRIPTS.some((key) => json.scripts?.[key]?.startsWith(BUN_PREFIX));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/dev/codegen/types/contributions.server.d.ts

@@ -3,8 +3,9 @@ import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
 /**
  * What each config's generated doc type gains beyond its own fields.
  *
- * Two contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
- * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with.
+ * Three contributors and they are the whole list: `versions` adds `versionId`, `upload` extends
+ * `UploadDoc`, adds its `sizes` member and filters out the fields its image sizes collide with,
+ * `url` adds the address.
  * The `fields` predicates are **ANDed** — each says which fields it still wants generated, and
  * a field has to survive both.
  *