rimecms 0.29.0 → 0.30.1

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

@@ -2,12 +2,14 @@ import { isAuthConfig } from '../../collections/auth/util.js';
 import cache from '../../dev/cache/index.server.js';
 import { isFormField } from '../../fields/util.js';
 import { logger } from '../../logger/index.server.js';
-import { isBlocksFieldRaw } from '../../../fields/blocks/index.js';
-import { isGroupFieldRaw } from '../../../fields/group/index.js';
-import { isRelationField } from '../../../fields/relation/index.js';
-import { isSelectField } from '../../../fields/select/index.js';
-import { isTabsFieldRaw } from '../../../fields/tabs/index.js';
-import { isTreeFieldRaw } from '../../../fields/tree/index.js';
+import { withoutDirectoriesSuffix, withoutVersionsSuffix } from '../../naming.js';
+import { BlocksBuilder } from '../../../fields/blocks/index.js';
+import { GroupFieldBuilder } from '../../../fields/group/index.js';
+import { RelationFieldBuilder } from '../../../fields/relation/index.js';
+import { SelectFieldBuilder } from '../../../fields/select/index.js';
+import { TabsBuilder } from '../../../fields/tabs/index.js';
+import { TreeBuilder } from '../../../fields/tree/index.js';
+import { isCamelCase } from '../../../util/string.js';
 function hasDuplicates(arr) {
     return [...new Set(arr.filter((e, i, a) => a.indexOf(e) !== i))];
 }
@@ -29,6 +31,24 @@ function hasDuplicateSlug(config) {
     }
     return [];
 }
+/**
+ * Check that all area/collection slugs are camelCase
+ */
+function validateSlugs(config) {
+    const errors = [];
+    const slugs = [
+        ...(config.collections || []).map((c) => c.slug),
+        ...(config.areas || []).map((a) => a.slug)
+    ]
+        .map(withoutVersionsSuffix)
+        .map(withoutDirectoriesSuffix);
+    for (const slug of slugs) {
+        if (!isCamelCase(slug)) {
+            errors.push(`Slug ${slug} is not a valid prototype slug`);
+        }
+    }
+    return errors;
+}
 /**
  * Prevent the panel user collection slug
  * to be used elsewhere
@@ -64,14 +84,14 @@ const validateDocumentFields = (documentConfig, config) => {
     const isCollection = (documentConfig) => documentConfig.type === 'collection';
     const isAuth = isCollection(documentConfig) && isAuthConfig(documentConfig);
     const registeredBlocks = {};
-    const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
+    // const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
     if (isAuth) {
-        const rolesField = fieldsCompiled
+        const rolesField = documentConfig.fields
             .filter(isFormField)
             .filter((f) => f.name === 'roles')
-            .filter((f) => isSelectField(f))[0];
-        const nameField = fieldsCompiled.filter(isFormField).filter((f) => f.name === 'name')[0];
-        const emailField = fieldsCompiled
+            .filter((f) => f instanceof SelectFieldBuilder)[0];
+        const nameField = documentConfig.fields.filter(isFormField).filter((f) => f.name === 'name')[0];
+        const emailField = documentConfig.fields
             .filter(isFormField)
             .find((f) => f.name === 'email' && f.type === 'email');
         if (!rolesField)
@@ -80,7 +100,7 @@ const validateDocumentFields = (documentConfig, config) => {
             errors.push(`Field email is missing in collection ${documentConfig.slug}`);
         if (!nameField)
             errors.push(`Field name is missing in collection ${documentConfig.slug}`);
-        if (!rolesField.many)
+        if (!rolesField.get.many)
             errors.push(`Field roles must have "many" enabled : select('roles').options(...).many(), even with a single option`);
     }
     const validateBlockField = (fields, blockType) => {
@@ -96,8 +116,8 @@ const validateDocumentFields = (documentConfig, config) => {
     };
     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}`);
+        if (!collectionsSlugs.includes(field.get.relationTo)) {
+            errors.push(`Relation field ${field.name} references unknown collection ${field.get.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
         }
     };
     const validateFields = (fields) => {
@@ -116,17 +136,17 @@ const validateDocumentFields = (documentConfig, config) => {
             return pattern.test(name) && !name.includes('-') && !name.includes(' ');
         }
         function validateTabs(field) {
-            const duplicates = hasDuplicates(field.tabs.map((t) => t.name));
+            const duplicates = hasDuplicates(field.get.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)) {
+            if (field instanceof TabsBuilder) {
                 validateTabs(field);
-                for (const tab of field.tabs) {
-                    validateFields(tab.fields);
+                for (const tab of field.get.tabs) {
+                    validateFields(tab.get.fields);
                 }
             }
             // If field is not a Formfield eg. Separator then continue
@@ -134,7 +154,7 @@ const validateDocumentFields = (documentConfig, config) => {
                 continue;
             }
             // Check that a field wich has field._root = true is not localized
-            if ('_root' in field && field._root && field.localized) {
+            if (field.get.root && field.get.localized) {
                 errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with _root = true, can't be localized`);
             }
             // Check for malformed field.name
@@ -142,8 +162,8 @@ const validateDocumentFields = (documentConfig, config) => {
                 errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
             }
             // Recursive check into Blocks
-            if (isBlocksFieldRaw(field)) {
-                for (const block of field.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) {
@@ -153,25 +173,25 @@ const validateDocumentFields = (documentConfig, config) => {
                     else {
                         registeredBlocks[block.name] = block;
                     }
-                    validateFields(block.fields.filter(isFormField));
-                    validateBlockField(block.fields.filter(isFormField), block.name);
+                    validateFields(block.get.fields.filter(isFormField));
+                    validateBlockField(block.get.fields.filter(isFormField), block.name);
                 }
                 // Recursive check into Tree
             }
-            else if (isTreeFieldRaw(field)) {
-                validateFields(field.fields.filter(isFormField));
+            else if (field instanceof TreeBuilder) {
+                validateFields(field.get.fields.filter(isFormField));
                 // Recursive check into Tabs
             }
-            else if (isGroupFieldRaw(field)) {
-                validateFields(field.fields.filter(isFormField));
+            else if (field instanceof GroupFieldBuilder) {
+                validateFields(field.get.fields.filter(isFormField));
                 // Check relation field
             }
-            else if (isRelationField(field)) {
+            else if (field instanceof RelationFieldBuilder) {
                 validateRelationField(field);
             }
         }
     };
-    validateFields(documentConfig.fields.map((f) => f.compile()));
+    validateFields(documentConfig.fields);
     return errors;
 };
 const hasDatabase = (config) => {
@@ -192,9 +212,9 @@ function validateAuthCollections(config) {
     return errors;
 }
 function validate(config) {
-    logger.debug('Validating config...');
     const validateFunctions = [
         hasDuplicateSlug,
+        validateSlugs,
         hasUsersSlug,
         validateFields,
         hasDatabase,

package/dist/core/config/shared/find-thumbnail.js

@@ -1,29 +1,29 @@
 import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import { isGroupField } from '../../../fields/group/index.js';
+import { GroupFieldBuilder } from '../../../fields/group/index.js';
 import { RelationFieldBuilder } from '../../../fields/relation/index.js';
 import { TabsBuilder } from '../../../fields/tabs/index.js';
 export function findThumbnailField(fields = [], basePath = '') {
     for (const field of fields) {
         // Direct check for isThumbnail
         if (field instanceof RelationFieldBuilder &&
-            'isThumbnail' in field.raw &&
-            field.raw.isThumbnail === true) {
-            const path = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
+            'isThumbnail' in field.get &&
+            field.get.isThumbnail === true) {
+            const path = basePath ? `${basePath}.${field.name}` : field.name;
             return { field, path };
         }
         // Check in group
-        if (isGroupField(field.raw) && field.raw.fields) {
-            const groupPath = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
-            const found = findThumbnailField(field.raw.fields, groupPath);
+        if (field instanceof GroupFieldBuilder && field.get.fields) {
+            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
+            const found = findThumbnailField(field.get.fields, groupPath);
             if (found)
                 return found;
         }
         // Check in tabs
-        if (field instanceof TabsBuilder && field.raw.tabs) {
-            for (const tab of field.raw.tabs) {
-                if (tab.raw.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.raw.name}` : tab.raw.name;
-                    const found = findThumbnailField(tab.raw.fields, tabPath);
+        if (field instanceof TabsBuilder && field.get.tabs) {
+            for (const tab of field.get.tabs) {
+                if (tab.get.fields) {
+                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
+                    const found = findThumbnailField(tab.get.fields, tabPath);
                     if (found)
                         return found;
                 }

package/dist/core/config/shared/find-title.js

@@ -1,30 +1,30 @@
 import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import { isGroupField } from '../../../fields/group/index.js';
+import { GroupFieldBuilder } from '../../../fields/group/index.js';
 import { TabsBuilder } from '../../../fields/tabs/index.js';
 export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email', 'richText'].includes(field.type);
 export function findTitleField(fields = [], basePath = '') {
     for (const field of fields) {
         // Direct check for isTitle
         if (field instanceof FormFieldBuilder &&
-            hasMaybeTitle(field.raw) &&
-            'isTitle' in field.raw &&
-            field.raw.isTitle === true) {
-            const path = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
+            hasMaybeTitle(field.get) &&
+            'isTitle' in field.get &&
+            field.get.isTitle === true) {
+            const path = basePath ? `${basePath}.${field.name}` : field.name;
             return { field, path };
         }
         // Check in group
-        if (isGroupField(field.raw) && field.raw.fields) {
-            const groupPath = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
-            const found = findTitleField(field.raw.fields, groupPath);
+        if (field instanceof GroupFieldBuilder && field.get.fields) {
+            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
+            const found = findTitleField(field.get.fields, groupPath);
             if (found)
                 return found;
         }
         // Check in tabs
-        if (field instanceof TabsBuilder && field.raw.tabs) {
-            for (const tab of field.raw.tabs) {
-                if (tab.raw.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.raw.name}` : tab.raw.name;
-                    const found = findTitleField(tab.raw.fields, tabPath);
+        if (field instanceof TabsBuilder && field.get.tabs) {
+            for (const tab of field.get.tabs) {
+                if (tab.get.fields) {
+                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
+                    const found = findTitleField(tab.get.fields, tabPath);
                     if (found)
                         return found;
                 }

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

@@ -10,7 +10,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
     const slug = withDirectoriesSuffix(collection.slug);
     const directoriesConfig = collection.upload.directories;
     // else create the directory collection
-    let directoriesCollection = {
+    const directoriesCollection = {
         slug: slug,
         kebab: withDirectoriesSuffix(collection.kebab),
         versions: undefined,

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

@@ -1 +1,2 @@
 export declare const PACKAGE_NAME = "rimecms";
+export declare const RIME_DEV_CACHE_DIR: string;

package/dist/core/constant.server.js

@@ -1 +1,3 @@
+import path from 'path';
 export const PACKAGE_NAME = 'rimecms';
+export const RIME_DEV_CACHE_DIR = path.resolve(process.cwd(), 'node_modules', '.rime');

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

@@ -1,12 +1,12 @@
+import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
 import fs from 'fs';
 import path from 'path';
 const dev = process.env.NODE_ENV === 'development';
-const cachePath = path.resolve(process.cwd(), '.rime');
-if (!fs.existsSync(cachePath) && dev) {
-    fs.mkdirSync(cachePath);
+if (!fs.existsSync(RIME_DEV_CACHE_DIR) && dev) {
+    fs.mkdirSync(RIME_DEV_CACHE_DIR);
 }
 function get(key) {
-    const keyPath = path.join(cachePath, key + '.txt');
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
     const exist = fs.existsSync(keyPath);
     if (exist) {
         return fs.readFileSync(keyPath).toString();
@@ -14,20 +14,20 @@ function get(key) {
     return false;
 }
 function set(key, value) {
-    if (!fs.existsSync(cachePath)) {
-        fs.mkdirSync(cachePath);
+    if (!fs.existsSync(RIME_DEV_CACHE_DIR)) {
+        fs.mkdirSync(RIME_DEV_CACHE_DIR);
     }
-    const keyPath = path.join(cachePath, key + '.txt');
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
     fs.writeFileSync(keyPath, value);
 }
 function del(key) {
-    const keyPath = path.join(cachePath, key + '.txt');
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
     if (fs.existsSync(keyPath)) {
         fs.rmSync(keyPath, { force: true });
     }
 }
 function clear() {
-    fs.rmSync(cachePath, { recursive: true });
+    fs.rmSync(RIME_DEV_CACHE_DIR, { recursive: true });
 }
 export default {
     get,

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

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { logger } from '../../../logger/index.server.js';
 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 { envProduction, polkaServer } from './templates.js';
@@ -22,8 +23,7 @@ export const build = (args) => {
         rmSync('./app', { recursive: true, force: true });
     }
     // Build
-    mkdirSync('./build', { recursive: true });
-    // spawnSync('./node_modules/.bin/vite', ['build'], { stdio: 'inherit' });
+    spawnSync('./node_modules/.bin/vite', ['build'], { stdio: 'inherit' });
     console.log('');
     // Create app directory
     mkdirSync('./app', { recursive: true });

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

@@ -1,3 +1,4 @@
+import { RIME_DEV_CACHE_DIR } from '../../../constant.server.js';
 import { logger } from '../../../logger/index.server.js';
 import { rmSync } from 'node:fs';
 import path from 'node:path';
@@ -24,7 +25,7 @@ export const clear = async (args) => {
         return logger.info('Operation cancelled. Great!');
     }
     // Remove directories
-    rmSync(path.join('.rime'), { recursive: true, force: true });
+    rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
     rmSync(path.join('src', 'routes', '(rime)'), { recursive: true, force: true });
     rmSync(path.join('src', 'lib', INPUT_DIR), { recursive: true, force: true });
     rmSync(path.join('src', 'lib', OUTPUT_DIR), { recursive: true, force: true });

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

@@ -1,3 +1,4 @@
+import { RIME_DEV_CACHE_DIR } from '../../../constant.server.js';
 import cache from '../../cache/index.server.js';
 import { sanitize } from '../../generate/sanitize/index.server.js';
 import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
@@ -12,8 +13,8 @@ export const generate = async (args) => {
      */
     function clearConfigCache() {
         try {
-            rmSync(path.join(process.cwd(), '.rime'), { recursive: true, force: true });
-            mkdirSync(path.join(process.cwd(), '.rime'));
+            rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
+            mkdirSync(RIME_DEV_CACHE_DIR);
         }
         catch (err) {
             logger.error(err.message);

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

@@ -83,7 +83,7 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
             return;
         }
         let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
-        const updates = ['\\.rime', '\\.cache', '/logs', '/db', '\\+rime.generated'];
+        const updates = ['\\.cache', '/logs', '/db', '\\+rime.generated'];
         if (!gitignoreContent.includes('# rime'))
             gitignoreContent += '\n# rime';
         for (const line of updates) {

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

@@ -37,8 +37,8 @@ function generateRoutes(config) {
         }
     }
     // 4. Write the [slug=collection]/[slug=area] param matchers
-    fs.writeFileSync(path.join(paramsDir, 'collection.ts'), paramMatcher((config.collections || []).map((c) => c.slug)));
-    fs.writeFileSync(path.join(paramsDir, 'area.ts'), paramMatcher((config.areas || []).map((a) => a.slug)));
+    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)));
     // 5. Handle custom routes from config
     const customRoutes = config.panel?.routes;
     if (customRoutes) {

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

@@ -171,50 +171,50 @@ export async function generateTypesString(config) {
         for (const field of fields) {
             if (field instanceof BlocksBuilder) {
                 {
-                    for (const block of field.raw.blocks) {
-                        if (!registeredBlocks.includes(block.raw.name)) {
-                            const templates = await buildFieldsTypes(block.raw.fields
+                    for (const block of field.get.blocks) {
+                        if (!registeredBlocks.includes(block.name)) {
+                            const templates = await buildFieldsTypes(block.get.fields
                                 .filter((field) => field instanceof FormFieldBuilder)
                                 .filter((field) => field.name !== 'type'));
-                            blocksTypes.push(makeBlockType(block.raw.name, templates.join('\n\t')));
-                            registeredBlocks.push(block.raw.name);
-                            buildblocksTypes(block.raw.fields);
+                            blocksTypes.push(makeBlockType(block.name, templates.join('\n\t')));
+                            registeredBlocks.push(block.name);
+                            buildblocksTypes(block.get.fields);
                         }
                     }
                 }
             }
             else if (field instanceof TabsBuilder) {
-                for (const tab of field.raw.tabs) {
-                    await buildblocksTypes(tab.raw.fields);
+                for (const tab of field.get.tabs) {
+                    await buildblocksTypes(tab.get.fields);
                 }
             }
             else if (field instanceof GroupFieldBuilder) {
-                await buildblocksTypes(field.raw.fields);
+                await buildblocksTypes(field.get.fields);
             }
             else if (field instanceof TreeBuilder) {
-                await buildblocksTypes(field.raw.fields);
+                await buildblocksTypes(field.get.fields);
             }
         }
     };
     const buildTreeBlockTypes = async (fields) => {
         for (const field of fields) {
             if (field instanceof BlocksBuilder) {
-                for (const block of field.raw.blocks) {
-                    await buildTreeBlockTypes(block.raw.fields);
+                for (const block of field.get.blocks) {
+                    await buildTreeBlockTypes(block.get.fields);
                 }
             }
             else if (field instanceof TabsBuilder) {
-                for (const tab of field.raw.tabs) {
-                    await buildTreeBlockTypes(tab.raw.fields);
+                for (const tab of field.get.tabs) {
+                    await buildTreeBlockTypes(tab.get.fields);
                 }
             }
             else if (field instanceof GroupFieldBuilder) {
-                await buildTreeBlockTypes(field.raw.fields);
+                await buildTreeBlockTypes(field.get.fields);
             }
             else if (field instanceof TreeBuilder) {
                 const treeBlockTypeName = `Tree${toPascalCase(field.name)}`;
                 if (!registeredTreeBlocks.includes(treeBlockTypeName)) {
-                    const treeFieldsTypes = await buildFieldsTypes(field.raw.fields.filter((field) => field instanceof FormFieldBuilder));
+                    const treeFieldsTypes = await buildFieldsTypes(field.get.fields.filter((field) => field instanceof FormFieldBuilder));
                     const treeBlockType = makeTreeBlockType(treeBlockTypeName, treeFieldsTypes.join('\n'));
                     treeBlocksTypes.push(treeBlockType);
                     registeredTreeBlocks.push(treeBlockTypeName);
@@ -227,7 +227,7 @@ export async function generateTypesString(config) {
         if (isUploadConfig(collection) && collection.upload.imageSizes?.length) {
             fields = collection.fields
                 .filter((f) => f instanceof FormFieldBuilder)
-                .filter((field) => !collection.upload.imageSizes.some((size) => size.name === field.raw.name));
+                .filter((field) => !collection.upload.imageSizes.some((size) => size.name === field.name));
         }
         const fieldsTypesList = await buildFieldsTypes(fields);
         if (collection.versions) {

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

@@ -1,6 +1,7 @@
 import dotenv from 'dotenv';
 import { existsSync, rmSync } from 'node:fs';
 import path from 'node:path';
+import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
 import { ensureHasInit } from '../../ensure.server.js';
 import { logger } from '../../logger/index.server.js';
 import { INPUT_DIR, OUTPUT_DIR } from '../constants.js';
@@ -10,6 +11,13 @@ const dev = process.env.NODE_ENV === 'development';
 export function rime() {
     const VCoreId = '$rime/config';
     const VSchemaId = '$rime/schema';
+    /** General-purpose server/browser split, usable anywhere in the app (not just rime's own
+     *  field code — see relation/index.ts for the first user). `import { x } from '$rime/runtime'`
+     *  resolves to a sibling `server.ts` (server builds) or `browser.ts` (browser builds) next
+     *  to whichever file does the importing — the importer's path travels encoded in the
+     *  resolved id since `load()` only receives the id, not the importer. */
+    const VRuntimeId = '$rime/runtime';
+    const VRuntimeMarker = `\0${VRuntimeId}::`;
     const resolvedVModule = (name) => '\0' + name;
     return {
         name: 'virtual-rime',
@@ -19,10 +27,9 @@ export function rime() {
                 dev && ensureHasInit();
                 // Check if we need to rebuild
                 const shouldRebuild = process.argv.includes('--rebuild');
-                const rimeDevCacheDir = path.resolve(process.cwd(), '.rime');
-                if (shouldRebuild && existsSync(rimeDevCacheDir)) {
-                    rmSync(rimeDevCacheDir, { recursive: true, force: true });
-                    logger.info('--rebuild : .rime folder deleted');
+                if (shouldRebuild && existsSync(RIME_DEV_CACHE_DIR)) {
+                    rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
+                    logger.info('--rebuild : node_modules/.rime folder deleted');
                 }
             });
             // Add a watcher for sanitizing config changes
@@ -86,13 +93,16 @@ export function rime() {
                     return [module];
             }
         },
-        resolveId(id) {
+        resolveId(id, importer) {
             if (id === VCoreId) {
                 return resolvedVModule(id);
             }
             if (id === VSchemaId) {
                 return resolvedVModule(id);
             }
+            if (id === VRuntimeId && importer) {
+                return `${VRuntimeMarker}${importer}`;
+            }
             return null;
         },
         load(id) {
@@ -108,6 +118,12 @@ export function rime() {
                     return `export * from '${modulePath}'; export { default } from '${modulePath}';`;
                 }
             }
+            if (id.startsWith(VRuntimeMarker)) {
+                const importer = id.slice(VRuntimeMarker.length);
+                const dir = path.dirname(importer);
+                const target = path.join(dir, isServer ? 'runtime.server.ts' : 'runtime.ts');
+                return `export * from '${target.replace(/\.ts$/, '.js')}';`;
+            }
             return null;
         }
     };

package/dist/core/fields/builders/boolean-builder.d.ts

@@ -1,4 +1,5 @@
 import type { DefaultValueFn, FieldValidationFunc, FormField } from '../../../fields/types.js';
+import type { DataType } from './form-field-builder.js';
 import { FormFieldBuilder } from './form-field-builder.js';
 type BooleanField = FormField & {
     type: any;
@@ -6,9 +7,10 @@ type BooleanField = FormField & {
     defaultValue?: boolean | DefaultValueFn<boolean>;
     validate?: FieldValidationFunc<BooleanField>;
 };
-export declare class BooleanFieldBuilder<T extends BooleanField> extends FormFieldBuilder<T> {
+export declare class BooleanFieldBuilder<T extends BooleanField = BooleanField> extends FormFieldBuilder<T> {
     constructor(name: string, type: string);
     defaultValue(value: boolean | DefaultValueFn<boolean>): this;
+    get dataType(): DataType;
     compile(): import("../../../util/types.js").WithoutBuilders<T> & {
         component: import("svelte").Component<any>;
         cell?: import("svelte").Component<{

package/dist/core/fields/builders/boolean-builder.js

@@ -8,6 +8,9 @@ export class BooleanFieldBuilder extends FormFieldBuilder {
         this.field.defaultValue = value;
         return this;
     }
+    get dataType() {
+        return 'boolean';
+    }
     compile() {
         if (!this.field.validate) {
             this.field.validate = (value) => typeof value === 'boolean' || 'Should be true/false';

package/dist/core/fields/builders/field-builder.d.ts

@@ -1,10 +1,22 @@
 import type { WithoutBuilders } from '../../../util/types.js';
 import type { Component } from 'svelte';
-import type { Field } from '../../../fields/types.js';
+import type { Field, FieldAccess } from '../../../fields/types.js';
+/** Method-syntax (not `foo: () => ...` property syntax) so subtype checks
+ *  like `FormFieldBuilder<SlugField> -> FormFieldBuilder<FormField>` — used
+ *  all over the panel, where a concrete field builder flows into a
+ *  generically-typed prop — stay bivariant on their params, exactly like the
+ *  class methods this replaced. Property syntax would make TS check those
+ *  params strictly/contravariantly and break that assignability. */
+export type FieldRun = {
+    canRead(...args: Parameters<FieldAccess>): boolean;
+    canCreate(...args: Parameters<FieldAccess>): boolean;
+    canUpdate(...args: Parameters<FieldAccess>): boolean;
+};
 export declare class FieldBuilder<T extends Field = Field> {
     field: T;
     _metaUrl?: string;
     constructor(type: string);
+    get name(): string;
     className(str: string): this;
     compile(): WithoutBuilders<T> & {
         component: Component<any>;
@@ -14,7 +26,28 @@ export declare class FieldBuilder<T extends Field = Field> {
     };
     live(bool: boolean): this;
     get type(): string;
-    get raw(): T;
+    /**
+     * Raw field data, plus the couple of properties that a bare `this.field`
+     * read can't give you: `localized`/`root` default to `false` here since
+     * only FormFieldBuilder fields ever set them — container fields like Tabs
+     * answer `false` rather than making every caller check
+     * `instanceof FormFieldBuilder` first just to ask this one question.
+     * Everything else on `T` (Tabs' `tabs`, Blocks' `blocks`, ...) comes
+     * through unchanged via the spread — no per-subclass override needed.
+     */
+    get get(): T & {
+        localized: boolean;
+        root: boolean;
+    };
+    /** Behavior the builder runs on your behalf (invoking a stored function) —
+     *  see `.get` for plain data reads. Fields without an access concept
+     *  (Tabs) default every check to allowed, matching how the field-less case
+     *  already behaved. Params are unused here but must match FormFieldBuilder's
+     *  override signature — TS checks generic-constraint satisfaction
+     *  (`T extends FieldBuilder<any>`) strictly, not with the bivariant
+     *  leniency normal overrides get, so a param-less base signature breaks
+     *  assignability everywhere. */
+    get run(): FieldRun;
     get component(): Component<any> | null;
     get cell(): Component<{
         value: any;