rimecms 0.30.2 → 0.31.0

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

@@ -1,6 +1,6 @@
 import { logger } from '../../../logger/index.server.js';
 import { execSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync } from 'fs';
 import path from 'path';
 const packageManagersMap = {
     yarn: 'yarn.lock',
@@ -9,22 +9,24 @@ const packageManagersMap = {
     npm: 'package-lock.json',
     deno: 'deno.lock'
 };
+const deps = ['drizzle-orm', '@libsql/client', '@lucide/svelte', 'sharp'];
+const devDeps = ['@sveltejs/adapter-node', 'drizzle-kit'];
 const packageManagerConfigs = {
     yarn: {
         command: 'echo "yarn is not supported, please use pnpm or npm" && exit 1'
     },
     pnpm: {
-        command: 'pnpm add -D drizzle-kit && pnpm add -D @sveltejs/adapter-node && pnpm add drizzle-orm @lucide/svelte sharp',
-        preInstall: updatePackageJsonForPnpm,
+        command: `pnpm add -D ${devDeps.join(' ')} && pnpm add ${deps.join(' ')}`,
+        preInstall: configurePnpm,
         postInstall: () => {
             execSync('pnpm rebuild');
         }
     },
     bun: {
-        command: 'bun add -D drizzle-kit && bun add -D @sveltejs/adapter-node && bun add drizzle-orm @lucide/svelte sharp'
+        command: `bun add -D ${devDeps.join(' ')} && bun add ${deps.join(' ')}`
     },
     npm: {
-        command: 'npm install -D drizzle-kit && npm install -D @sveltejs/adapter-node && npm install drizzle-orm @lucide/svelte sharp'
+        command: `npm install -D ${devDeps.join(' ')} && npm install ${deps.join(' ')}`
     },
     deno: {
         command: 'echo "deno is not supported, please use pnpm or npm" && exit 1'
@@ -55,7 +57,7 @@ export function getInvokingPackageManager() {
     return 'npm';
 }
 export function installDependencies() {
-    const pm = getPackageManager();
+    const pm = getInvokingPackageManager();
     if (pm === 'deno' || pm === 'yarn') {
         throw new Error('Unsupported package manager ' + pm);
     }
@@ -68,28 +70,29 @@ export function installDependencies() {
     // Post installation hooks
     config.postInstall?.();
 }
-function updatePackageJsonForPnpm() {
-    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-    if (!existsSync(packageJsonPath)) {
-        logger.warn('package.json not found, skipping pnpm configuration');
-        return;
-    }
+/**
+ * pnpm 11 no longer reads the "pnpm" field in package.json (onlyBuiltDependencies
+ * included) - every pnpm-specific setting moved to pnpm-workspace.yaml, and
+ * onlyBuiltDependencies itself was replaced by allowBuilds (a name -> boolean map).
+ * `pnpm config set --location=project` writes there directly (creating the file if
+ * it doesn't exist yet, even for a non-monorepo single package).
+ *
+ * strictDepBuilds is also now on by default: any dependency (however deep) with a
+ * build script that isn't in allowBuilds hard-fails the whole install with
+ * ERR_PNPM_IGNORED_BUILDS instead of just skipping that one script. allowBuilds only
+ * covers esbuild/sharp; the rest of this command's tree (drizzle-kit, adapter-node,
+ * ...) will always have *something* pnpm hasn't seen before, and pinning every one of
+ * them here would just break again on their next update - so strict-dep-builds is
+ * turned off the same way.
+ */
+function configurePnpm() {
+    const allowBuilds = JSON.stringify({ esbuild: false, sharp: true, 'better-sqlite3': false });
     try {
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-        // Initialize pnpm configuration if it doesn't exist
-        if (!packageJson.pnpm) {
-            packageJson.pnpm = {};
-        }
-        // Update onlyBuiltDependencies
-        const existingBuiltDeps = packageJson.pnpm.onlyBuiltDependencies || [];
-        const newBuiltDeps = ['esbuild', 'sharp'];
-        // Merge and deduplicate
-        const mergedBuiltDeps = [...new Set([...existingBuiltDeps, ...newBuiltDeps])];
-        packageJson.pnpm.onlyBuiltDependencies = mergedBuiltDeps;
-        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, '\t'), 'utf-8');
-        logger.info('[✓] Updated package.json with pnpm configuration');
+        execSync(`pnpm config set --location=project --json allowBuilds '${allowBuilds}'`);
+        execSync('pnpm config set --location=project strict-dep-builds false');
+        logger.info('[✓] Configured pnpm-workspace.yaml: allowBuilds (sharp) and strict-dep-builds (false)');
     }
     catch (error) {
-        logger.error('Failed to update package.json for pnpm:', error);
+        logger.error('Failed to configure pnpm:', error);
     }
 }

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

@@ -1,2 +1,21 @@
-export const OUTPUT_DIR: "+rime.generated";
-export const INPUT_DIR: "+rime";
+export declare const OUTPUT_DIR = "+rime.generated";
+export declare const INPUT_DIR = "+rime";
+/** Where the panel/live route templates (common.server.ts) should import the client config
+ * from, and where the dev-server watcher/hot-reload should read the server config from —
+ * one source of truth instead of hardcoding the path at each call site. */
+export declare function configImportPaths(): {
+    client: string;
+    server: string;
+};
+/** Same idea as configImportPaths — one source of truth for where the generated schema
+ * lives instead of hardcoding the path at each call site. */
+export declare function schemaPath(root?: string): string;
+/**
+ * True when `metaUrl` (pass the caller's own `import.meta.url` — this can't be one shared
+ * value, it depends on which file is asking) is running from inside an installed `rimecms`
+ * package (node_modules/rimecms/...), false when running from rime's own repo. Deliberately
+ * filesystem-based rather than an env var: a shell dotenv plugin auto-loading this repo's own
+ * .env (which used to set IS_RIME_REPO=true) into every child process — including an unrelated
+ * consumer app's dev server — made that value unreliable; this can't leak the same way.
+ */
+export declare function isInstalledDependency(metaUrl: string): boolean;

package/dist/core/dev/constants.js

@@ -1,2 +1,28 @@
+import path from 'node:path';
 export const OUTPUT_DIR = '+rime.generated';
 export const INPUT_DIR = '+rime';
+/** Where the panel/live route templates (common.server.ts) should import the client config
+ * from, and where the dev-server watcher/hot-reload should read the server config from —
+ * one source of truth instead of hardcoding the path at each call site. */
+export function configImportPaths() {
+    return {
+        client: `$lib/${OUTPUT_DIR}/rime.config.js`,
+        server: `$lib/${OUTPUT_DIR}/rime.config.server.js`
+    };
+}
+/** Same idea as configImportPaths — one source of truth for where the generated schema
+ * lives instead of hardcoding the path at each call site. */
+export function schemaPath(root = process.cwd()) {
+    return path.resolve(root, 'src/lib', OUTPUT_DIR, 'schema.server.ts');
+}
+/**
+ * True when `metaUrl` (pass the caller's own `import.meta.url` — this can't be one shared
+ * value, it depends on which file is asking) is running from inside an installed `rimecms`
+ * package (node_modules/rimecms/...), false when running from rime's own repo. Deliberately
+ * filesystem-based rather than an env var: a shell dotenv plugin auto-loading this repo's own
+ * .env (which used to set IS_RIME_REPO=true) into every child process — including an unrelated
+ * consumer app's dev server — made that value unreliable; this can't leak the same way.
+ */
+export function isInstalledDependency(metaUrl) {
+    return metaUrl.includes('/node_modules/rimecms/');
+}

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

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

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

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

package/dist/core/dev/generate/runtime/index.server.d.ts

@@ -0,0 +1,40 @@
+export type RuntimeRegistryEntry = {
+    client: string;
+    server: string;
+};
+export type RuntimeRegistry = Map<string, RuntimeRegistryEntry>;
+/**
+ * Finds an installed package's root by walking up from `fromDir`, checking each ancestor's
+ * `node_modules/<pkgName>` directly for a `package.json` — the pre-`exports` Node resolution
+ * algorithm, pure directory existence, no `exports`-conditions matching involved at all.
+ *
+ * Needed in place of `require.resolve`/`import.meta.resolve`: both gate on a package's own
+ * `exports` map matching some condition set (`"require"`/`"default"` for the former, whatever
+ * conditions the resolving runtime declares for the latter), and a package that only exposes
+ * conditions neither uses — confirmed in practice with rime's own `"."` export, `types`/
+ * `svelte`/`import` only, no `"require"`/`"default"` fallback — fails to resolve even its own
+ * main entry through either API. This sidesteps that entirely: `node_modules/<pkgName>` is a
+ * real directory (or, under pnpm, a real symlink `fs.existsSync` follows transparently)
+ * regardless of what that package's `exports` map declares.
+ */
+export declare function findInstalledPackageRoot(pkgName: string, fromDir: string): string;
+/**
+ * Direct, single-lookup check for one `<root>/<name>/module(.server)?.ts|js` pair — no
+ * directory walk, just the two `fs.existsSync`-style checks `findModuleFile` already does.
+ * Used by the Vite plugin's `resolveId`/`load` for on-demand resolution of a `$rime/modules`
+ * self-reference; `scanModulePairs` below (a real walk) stays reserved for the barrel (which
+ * needs every pair at once) and type generation.
+ */
+export declare function findModulePair(root: string, name: string): RuntimeRegistryEntry | null;
+/**
+ * Recursively finds every `module`/`module.server` folder under `root`, registered under the
+ * containing folder's path relative to `root` — e.g. `fields/relation/module.ts` under a
+ * `src/lib`-rooted scan registers as `fields/relation`. Used by the `$rime/modules` barrel
+ * (live, dev-mode only) and by `generate-manifest` (once, at prepack, scanning `dist/`).
+ *
+ * Either file alone is enough to register (single-sided is legitimate — a server-only piece,
+ * e.g. a collection's hooks, never needs a hand-written client stub; the missing side is just
+ * an empty string here, same convention `findModulePair` above uses). `rime.generated/` is
+ * skipped since it's sanitize's own output, unrelated to this.
+ */
+export declare function scanModulePairs(root: string): RuntimeRegistry;

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

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { OUTPUT_DIR } from '../../constants.js';
+/**
+ * Finds an installed package's root by walking up from `fromDir`, checking each ancestor's
+ * `node_modules/<pkgName>` directly for a `package.json` — the pre-`exports` Node resolution
+ * algorithm, pure directory existence, no `exports`-conditions matching involved at all.
+ *
+ * Needed in place of `require.resolve`/`import.meta.resolve`: both gate on a package's own
+ * `exports` map matching some condition set (`"require"`/`"default"` for the former, whatever
+ * conditions the resolving runtime declares for the latter), and a package that only exposes
+ * conditions neither uses — confirmed in practice with rime's own `"."` export, `types`/
+ * `svelte`/`import` only, no `"require"`/`"default"` fallback — fails to resolve even its own
+ * main entry through either API. This sidesteps that entirely: `node_modules/<pkgName>` is a
+ * real directory (or, under pnpm, a real symlink `fs.existsSync` follows transparently)
+ * regardless of what that package's `exports` map declares.
+ */
+export function findInstalledPackageRoot(pkgName, fromDir) {
+    let dir = fromDir;
+    while (true) {
+        const candidate = path.join(dir, 'node_modules', pkgName);
+        if (fs.existsSync(path.join(candidate, 'package.json'))) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`$rime/modules: could not find installed package '${pkgName}' above ${fromDir}`);
+        }
+        dir = parent;
+    }
+}
+/** `module.ts` when scanning TS source, `module.js` when scanning a built `dist/`. */
+function findModuleFile(dir, baseName) {
+    for (const ext of ['.ts', '.js']) {
+        const candidate = path.join(dir, `${baseName}${ext}`);
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Direct, single-lookup check for one `<root>/<name>/module(.server)?.ts|js` pair — no
+ * directory walk, just the two `fs.existsSync`-style checks `findModuleFile` already does.
+ * Used by the Vite plugin's `resolveId`/`load` for on-demand resolution of a `$rime/modules`
+ * self-reference; `scanModulePairs` below (a real walk) stays reserved for the barrel (which
+ * needs every pair at once) and type generation.
+ */
+export function findModulePair(root, name) {
+    const dir = path.join(root, name);
+    const client = findModuleFile(dir, 'module');
+    const server = findModuleFile(dir, 'module.server');
+    return client || server ? { client: client ?? '', server: server ?? '' } : null;
+}
+/**
+ * Recursively finds every `module`/`module.server` folder under `root`, registered under the
+ * containing folder's path relative to `root` — e.g. `fields/relation/module.ts` under a
+ * `src/lib`-rooted scan registers as `fields/relation`. Used by the `$rime/modules` barrel
+ * (live, dev-mode only) and by `generate-manifest` (once, at prepack, scanning `dist/`).
+ *
+ * Either file alone is enough to register (single-sided is legitimate — a server-only piece,
+ * e.g. a collection's hooks, never needs a hand-written client stub; the missing side is just
+ * an empty string here, same convention `findModulePair` above uses). `rime.generated/` is
+ * skipped since it's sanitize's own output, unrelated to this.
+ */
+export function scanModulePairs(root) {
+    const registry = new Map();
+    if (!fs.existsSync(root))
+        return registry;
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name === OUTPUT_DIR)
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const client = findModuleFile(fullPath, 'module');
+            const server = findModuleFile(fullPath, 'module.server');
+            if (client || server) {
+                const key = path.relative(root, fullPath).split(path.sep).join('/');
+                registry.set(key, { client: client ?? '', server: server ?? '' });
+            }
+            walk(fullPath);
+        }
+    };
+    walk(root);
+    return registry;
+}

package/dist/core/dev/generate/runtime/parse-exports.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Top-level named + default export identifiers of a module — used by the Vite plugin's
+ * `exportFrom()` to stub out a side of a `$rime/<name>` pair that wasn't authored (e.g. a
+ * collection's server-only hook, requested by a client build), matching the real side's
+ * export names so ESM's static named-export binding doesn't throw at link time.
+ */
+export declare function parseExportNames(filePath: string): string[];

package/dist/core/dev/generate/runtime/parse-exports.server.js

@@ -0,0 +1,40 @@
+import { babelParse } from 'ast-kit';
+import * as t from '@babel/types';
+import fs from 'node:fs';
+/**
+ * Top-level named + default export identifiers of a module — used by the Vite plugin's
+ * `exportFrom()` to stub out a side of a `$rime/<name>` pair that wasn't authored (e.g. a
+ * collection's server-only hook, requested by a client build), matching the real side's
+ * export names so ESM's static named-export binding doesn't throw at link time.
+ */
+export function parseExportNames(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+    const names = [];
+    for (const node of ast.body) {
+        if (t.isExportNamedDeclaration(node)) {
+            if (node.declaration) {
+                if (t.isVariableDeclaration(node.declaration)) {
+                    for (const decl of node.declaration.declarations) {
+                        if (t.isIdentifier(decl.id))
+                            names.push(decl.id.name);
+                    }
+                }
+                else if ('id' in node.declaration &&
+                    node.declaration.id &&
+                    t.isIdentifier(node.declaration.id)) {
+                    names.push(node.declaration.id.name);
+                }
+            }
+            for (const spec of node.specifiers) {
+                if (t.isExportSpecifier(spec) && t.isIdentifier(spec.exported)) {
+                    names.push(spec.exported.name);
+                }
+            }
+        }
+        if (t.isExportDefaultDeclaration(node)) {
+            names.push('default');
+        }
+    }
+    return names;
+}

package/dist/core/dev/generate/sanitize/index.server.d.ts

@@ -1,10 +1,3 @@
-/**
- * $ prefix-based sanitizer that rules:
- * - All server-only config properties begin with $ (e.g., $url, $hooks)
- * - All server-only field methods begin with $ (e.g., $beforeSave, $beforeRead)
- * - Content must be pure functions or imports from .server.ts files
- * - Outputs to .generated folder, preserving original folder structure
- */
 export function sanitize(): Promise<void>;
 /**
  * Updates imports in server files to use server versions of split modules

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

@@ -15,6 +15,11 @@ import { INPUT_DIR, OUTPUT_DIR } from '../../constants.js';
  * - Outputs to .generated folder, preserving original folder structure
  */
 
+// The top-level config — real, hand-authored. Unlike every other .server.ts file under
+// +rime/ (copied verbatim, server-only, no client counterpart needed), this one always needs
+// a sanitized client copy too — the panel still needs +rime.generated/rime.config.ts.
+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);
@@ -66,12 +71,22 @@ export async function sanitize() {
     }
   }
 
-  // Also scan and copy all existing .server.ts files
-  const serverFiles = await scanServerFiles(configDir);
+  // Also scan and copy all existing .server.ts files — except the top-level config, which
+  // gets its own client+server split below instead of a plain verbatim copy.
+  const serverFiles = (await scanServerFiles(configDir)).filter(
+    (filePath) => path.relative(configDir, filePath) !== TOP_LEVEL_CONFIG
+  );
 
   // Scan and copy all other files (non-.ts files like .svelte, .json, etc.)
   const otherFiles = await scanOtherFiles(configDir);
 
+  // Top-level config split: same client/server treatment as every other split file below,
+  // just addressed by its fixed name instead of found via the scan (it's .server.ts-suffixed,
+  // so scanConfigFiles/allFiles never sees it). Runs after the pre-scan above so splitFiles is
+  // fully populated — this file's own `import { Pages } from './pages'`-style imports need to
+  // know which nested files themselves got split.
+  await processTopLevelConfig(configDir, outputDir, outputFiles, splitFiles);
+
   for (const filePath of allFiles) {
     const relativePath = path.relative(configDir, filePath);
     logger.debug(`   Processing: ${relativePath}`);
@@ -130,10 +145,13 @@ export async function sanitize() {
     }
   }
 
-  // Delete files that exist in current list but not in output list
+  // Delete files that exist in current list but not in output list. schema.server.ts is
+  // excluded — write.server.ts owns it (writes it straight into OUTPUT_DIR, see schemaPath()
+  // in constants.ts), sanitize() never adds it to outputFiles, so without this exclusion
+  // every sanitize run deletes it out from under write()'s own cache guard.
+  const SCHEMA_FILE = 'schema.server.ts';
   for (const existingFile of existingFiles) {
-    // Do not delete "schema.server.ts"
-    if (!outputFiles.has(existingFile) && existingFile !== 'schema.server.ts') {
+    if (existingFile !== SCHEMA_FILE && !outputFiles.has(existingFile)) {
       const fileToDelete = path.join(outputDir, existingFile);
       fs.unlinkSync(fileToDelete);
       logger.debug(`   Deleted: ${existingFile}`);
@@ -143,6 +161,40 @@ export async function sanitize() {
   logger.info('Sanitization complete');
 }
 
+/**
+ * The top-level config (src/lib/+rime/rime.config.server.ts) — real, hand-authored. Client
+ * copy via analyzeFile + sanitizeClientAst + removeUnusedImports, written into
+ * +rime.generated/, plus a server copy via updateServerImports so its own imports of nested
+ * split files resolve like every other split file's do.
+ */
+async function processTopLevelConfig(configDir, outputDir, outputFiles, splitFiles) {
+  const sourcePath = path.join(configDir, TOP_LEVEL_CONFIG);
+  if (!fs.existsSync(sourcePath)) return; // ensureUserConfigExist() already guards this
+
+  const content = fs.readFileSync(sourcePath, 'utf-8');
+  const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: false });
+  const analysis = analyzeFile(ast);
+
+  const clientPath = path.join(outputDir, 'rime.config.ts');
+  const serverPath = path.join(outputDir, TOP_LEVEL_CONFIG);
+  outputFiles.add(path.relative(outputDir, clientPath));
+  outputFiles.add(path.relative(outputDir, serverPath));
+
+  const clientAst = sanitizeClientAst(ast, analysis);
+  const cleanedAst = removeUnusedImports(clientAst);
+  const clientCode = generate(cleanedAst, { compact: false, comments: true }).code;
+  if (shouldWriteFile(clientPath, clientCode)) {
+    fs.writeFileSync(clientPath, clientCode);
+    logger.debug(`   Sanitized: rime.config.ts`);
+  }
+
+  const serverContent = updateServerImports(content, splitFiles, '.');
+  if (shouldWriteFile(serverPath, serverContent)) {
+    fs.writeFileSync(serverPath, serverContent);
+    logger.debug(`   Created: ${TOP_LEVEL_CONFIG}`);
+  }
+}
+
 async function scanConfigFiles(configDir) {
   const files = [];
 

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

@@ -6,15 +6,14 @@ import { logger } from '../../../logger/index.server.js';
 import { withVersionsSuffix } from '../../../naming.js';
 import { BlocksBuilder } from '../../../../fields/blocks/index.js';
 import { GroupFieldBuilder } from '../../../../fields/group/index.js';
-import { getFieldPrivateModule } from '../../../../fields/index.server.js';
 import { TabsBuilder } from '../../../../fields/tabs/index.js';
 import { TreeBuilder } from '../../../../fields/tree/index.js';
 import { trycatchSync } from '../../../../util/function.js';
 import { capitalize, toPascalCase } from '../../../../util/string.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { OUTPUT_DIR } from '../../constants.js';
-const IS_PACKAGE_DEV = process.env.IS_PACKAGE_DEV === 'true';
+import { isInstalledDependency, OUTPUT_DIR } from '../../constants.js';
+const IS_RIME_REPO = !isInstalledDependency(import.meta.url);
 // Relation  type
 const relationValueType = `
 export type RelationValue<T> =
@@ -110,12 +109,23 @@ const templateRegister = (config) => {
 };
 const templateDeclareVirtualModule = () => [
     `declare module '$rime/config' {`,
-    ...(IS_PACKAGE_DEV ? ['\t// eslint-disable-next-line no-restricted-imports'] : []),
+    ...(IS_RIME_REPO ? ['\t// eslint-disable-next-line no-restricted-imports'] : []),
     `\texport * from '${PACKAGE_NAME}/config/server';`,
     `}`,
     `declare module '$rime/schema' {`,
-    `\texport * from '$lib/+rime.generated/schema.server.js';`,
+    `\texport * from '$lib/rime.schema.server.js';`,
     `}`
+    // $rime/modules (the bare barrel) is typed by src/rime.modules.generated.d.ts instead —
+    // written directly by the Vite plugin's own dev-server watcher (regenerateModulesDeclaration
+    // in core/dev/vite/index.server.ts), not here, since it needs to react to module.(server.)ts
+    // files appearing/changing on their own, independent of a config regen.
+    //
+    // A package's own qualified $rime/modules/<pkg>/<path> references are self-contained —
+    // generate-manifest inserts a /// <reference> directly into each rewritten .d.ts file at
+    // prepack (see generate-manifest/index.server.ts), so this app never needs to know which
+    // installed packages exist or eagerly reference all of them; verified directly (a real tsc
+    // run resolves it correctly from a file two levels deep inside node_modules, zero consumer
+    // awareness needed).
 ].join('\n');
 /**
  * Generates type definitions for image sizes
@@ -155,17 +165,7 @@ export async function generateTypesString(config) {
      * @returns An array of string containing fields type definitions
      */
     const buildFieldsTypes = async (fields) => {
-        const strFields = [];
-        for (const field of fields) {
-            if (field instanceof FormFieldBuilder || field instanceof TabsBuilder) {
-                const fieldServerMethods = await getFieldPrivateModule(field);
-                if (fieldServerMethods) {
-                    const result = await Promise.resolve(fieldServerMethods.toType(field));
-                    strFields.push(result);
-                }
-            }
-        }
-        return strFields;
+        return fields.map((field) => field.use.generateType()).filter(Boolean);
     };
     const buildblocksTypes = async (fields) => {
         for (const field of fields) {
@@ -259,6 +259,7 @@ 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`;
     const locals = `declare global {
   namespace App {
     interface Locals {
@@ -292,7 +293,7 @@ export async function generateTypesString(config) {
 			/** Singleton providing access to auth, config and local-api */
       rime: ReturnType<
 				Awaited<
-					typeof import('./lib/${OUTPUT_DIR}/rime.config.server.ts').default
+					typeof import('${rimeConfigServerPath}').default
 				>['createRimeContext']
 			>;
       /** Flag enabled by the core plugin rime.cache when the API cache is ON */
@@ -314,10 +315,10 @@ export async function generateTypesString(config) {
   }
 }`;
     const content = [
-        ...(IS_PACKAGE_DEV ? ['// eslint-disable-next-line no-restricted-imports'] : []),
+        ...(IS_RIME_REPO ? ['// eslint-disable-next-line no-restricted-imports'] : []),
         `import '${PACKAGE_NAME}';`,
         `import type { Session } from 'better-auth';`,
-        ...(IS_PACKAGE_DEV ? ['// eslint-disable-next-line no-restricted-imports'] : []),
+        ...(IS_RIME_REPO ? ['// eslint-disable-next-line no-restricted-imports'] : []),
         typeImports,
         '',
         relationValueType,
@@ -357,7 +358,7 @@ function write(key, content, filePath) {
  */
 async function generateTypes(config) {
     const mainTypes = await generateTypesString(config);
-    const declarations = [templateDeclareVirtualModule()].join('\n');
+    const declarations = templateDeclareVirtualModule();
     const appGeneratedPath = path.resolve(process.cwd(), 'src', 'app.generated.d.ts');
     const virtualModuleGeneratedPath = path.resolve(process.cwd(), 'src', 'rime.generated.d.ts');
     write('app.generated', mainTypes, appGeneratedPath);