rimecms 0.31.5 → 0.32.1

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

@@ -1,368 +0,0 @@
-import { isUploadConfig } from '../../../collections/upload/util/config.js';
-import { PACKAGE_NAME } from '../../../constant.server.js';
-import cache from '../../cache/index.server.js';
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
-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 { 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 { GENERATED_DIR, isInstalledDependency, relativeImportSpecifier } from '../../constants.js';
-const IS_RIME_REPO = !isInstalledDependency(import.meta.url);
-// Relation  type
-const relationValueType = `
-export type RelationValue<T> =
-	| T[] // When depth > 0, fully populated docs
-	| { id?: string; relationTo: string; documentId: string }[] // When depth = 0, relation objects
-	| string[]
-	| string; // When sending data to update`;
-/**
- * Generate document's type name
- * @example
- * makeDocTypeName('pages')
- * // return PagesDoc
- */
-const makeDocTypeName = (slug) => `${capitalize(slug)}Doc`;
-/**
- * Generate the document's type definition
- * @returns the full document type
- */
-const templateDocType = (slug, content, upload) => `
-export type ${makeDocTypeName(slug)} = BaseDoc & ${upload ? 'UploadDoc & ' : ''} {
-  ${content};
-	[x: string]: unknown;
-}`;
-/**
- * Generates a type for a block with the given slug and content
- * @example
- * makeBlockType('hero', 'title: string')
- * // returns
- * export type BlockHero {
- *   id: string,
- *   type: 'hero',
- *   title: string
- * }
- */
-const makeBlockType = (slug, content) => `
-export type Block${toPascalCase(slug)} = {
-  id: string
-  type: '${slug}'
-  ${content}
-}`;
-/**
- * Generates a type for a treeBlock with the given slug and content
- * @example
- * makeTreeBlockType('TreeNav', 'title: string')
- * // returns
- * export type TreeNav {
- *   id: string,
- *   title: string
- *   _children: TreeNav[]
- * }
- */
-const makeTreeBlockType = (name, content) => `
-export type ${name} = {
-  id: string;
-  ${content};
-	_children: ${name}[]
-}`;
-/**
- * Generates the module declaration for registering document types
- * @returns A string containing the module declaration for type registration
- */
-const templateRegister = (config) => {
-    const collections = (config.collections || []).filter((c) => c._generateTypes !== false);
-    const areas = (config.areas || []).filter((c) => c._generateTypes !== false);
-    const registerCollections = collections.length
-        ? [
-            '\tinterface RegisterCollection {',
-            `${collections
-                .map((collection) => {
-                let collectionRegister = `\t\t'${collection.slug}': ${makeDocTypeName(collection.slug)}`;
-                if (collection.versions) {
-                    collectionRegister += `\n\t\t'${withVersionsSuffix(collection.slug)}': ${makeDocTypeName(collection.slug)}`;
-                }
-                return collectionRegister;
-            })
-                .join('\n')};`,
-            '\t}'
-        ]
-        : [];
-    const registerAreas = areas.length
-        ? [
-            '\tinterface RegisterArea {',
-            `${areas
-                .map((area) => {
-                const areaRegister = `\t\t'${area.slug}': ${makeDocTypeName(area.slug)}`;
-                return areaRegister;
-            })
-                .join('\n')};`,
-            '\t}'
-        ]
-        : [];
-    return ["declare module 'rimecms' {", ...registerCollections, ...registerAreas, '}'].join('\n');
-};
-const templateDeclareVirtualModule = () => [
-    `declare module '$rime/config' {`,
-    ...(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.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
- * @returns A string containing the type definition for image sizes
- */
-function generateImageSizesType(sizes) {
-    const sizesTypes = sizes
-        .map((size) => {
-        if (size.out && size.out.length > 1) {
-            return size.out.map((format) => `${size.name}_${format}: string`).join(', ');
-        }
-        else {
-            return `${size.name}: string`;
-        }
-    })
-        .join(', ');
-    return `\n\t\tsizes:{${sizesTypes}}`;
-}
-/**
- * Generates the complete TypeScript type definitions string based on the built configuration
- * @returns A string containing all type definitions
- */
-export async function generateTypesString(config) {
-    logger.info('Types generation...');
-    const collections = (config.collections || []).filter((c) => c._generateTypes !== false);
-    const areas = (config.areas || []).filter((c) => c._generateTypes !== false);
-    const blocksTypes = [];
-    const treeBlocksTypes = [];
-    const registeredBlocks = [];
-    const registeredTreeBlocks = [];
-    let imports = new Set(['BaseDoc', 'Navigation', 'RouteHandlers', 'User']);
-    const addImport = (string) => {
-        imports = new Set([...imports, string]);
-    };
-    /**
-     * Generates fields type definitions string based on a list of field
-     * @returns An array of string containing fields type definitions
-     */
-    const buildFieldsTypes = async (fields) => {
-        return fields.map((field) => field.use.generateType()).filter(Boolean);
-    };
-    const buildblocksTypes = async (fields) => {
-        for (const field of fields) {
-            if (field instanceof BlocksBuilder) {
-                {
-                    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.name, templates.join('\n\t')));
-                            registeredBlocks.push(block.name);
-                            buildblocksTypes(block.get.fields);
-                        }
-                    }
-                }
-            }
-            else if (field instanceof TabsBuilder) {
-                for (const tab of field.get.tabs) {
-                    await buildblocksTypes(tab.get.fields);
-                }
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                await buildblocksTypes(field.get.fields);
-            }
-            else if (field instanceof TreeBuilder) {
-                await buildblocksTypes(field.get.fields);
-            }
-        }
-    };
-    const buildTreeBlockTypes = async (fields) => {
-        for (const field of fields) {
-            if (field instanceof BlocksBuilder) {
-                for (const block of field.get.blocks) {
-                    await buildTreeBlockTypes(block.get.fields);
-                }
-            }
-            else if (field instanceof TabsBuilder) {
-                for (const tab of field.get.tabs) {
-                    await buildTreeBlockTypes(tab.get.fields);
-                }
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                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.get.fields.filter((field) => field instanceof FormFieldBuilder));
-                    const treeBlockType = makeTreeBlockType(treeBlockTypeName, treeFieldsTypes.join('\n'));
-                    treeBlocksTypes.push(treeBlockType);
-                    registeredTreeBlocks.push(treeBlockTypeName);
-                }
-            }
-        }
-    };
-    const processCollection = async (collection) => {
-        let fields = collection.fields;
-        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.name));
-        }
-        const fieldsTypesList = await buildFieldsTypes(fields);
-        if (collection.versions) {
-            fieldsTypesList.push('versionId: string');
-        }
-        let fieldsContent = fieldsTypesList.join('\n\t');
-        await buildTreeBlockTypes(fields);
-        await buildblocksTypes(fields);
-        if (isUploadConfig(collection)) {
-            addImport('UploadDoc');
-            if (collection.upload.imageSizes?.length) {
-                fieldsContent += generateImageSizesType(collection.upload.imageSizes);
-            }
-        }
-        return templateDocType(collection.slug, fieldsContent, !!collection.upload);
-    };
-    const processArea = async (area) => {
-        const fieldsTypesList = await buildFieldsTypes(area.fields);
-        if (area.versions) {
-            fieldsTypesList.push('versionId: string');
-        }
-        await buildTreeBlockTypes(area.fields);
-        await buildblocksTypes(area.fields);
-        return templateDocType(area.slug, fieldsTypesList.join('\n\t'));
-    };
-    const collectionsTypes = (await Promise.all(collections.map(processCollection))).join('\n');
-    const areasTypes = (await Promise.all(areas.map(processArea))).join('\n');
-    const hasBlocks = !!registeredBlocks.length;
-    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'`;
-    // app.generated.d.ts always sits at src/app.generated.d.ts (see generateTypes() below).
-    const rimeConfigServerPath = relativeImportSpecifier(path.resolve(process.cwd(), 'src'), path.resolve(process.cwd(), GENERATED_DIR, 'rime.config.server.ts'));
-    const locals = `declare global {
-  namespace App {
-    interface Locals {
-			/** Flag only ON when create the first panel user */
-			isInit?: boolean;
-			/** The better auth session */
-      session: Session | undefined;
-			/** The rime user document when authenticated */
-      user: User | undefined;
-			/**
-			 * Flag enabled when a create operation is triggered
-			 * by a auth/sign-up api call.
-			 */
-			isAutoSignIn?: boolean;
-			/** The full better-auth user */
-			betterAuthUser:
-			| {
-					id: string;
-					name: string;
-					email: string;
-					emailVerified: boolean;
-					createdAt: Date;
-					updatedAt: Date;
-					role?: string | null | undefined;
-					banned: boolean | null | undefined;
-					banReason?: string | null | undefined;
-					banExpires?: Date | null | undefined;
-					type: string;
-				}
-			| undefined;
-			/** Singleton providing access to auth, config and local-api */
-      rime: ReturnType<
-				Awaited<
-					typeof import('${rimeConfigServerPath}').default
-				>['createRimeContext']
-			>;
-      /** Flag enabled by the core plugin rime.cache when the API cache is ON */
-      cacheEnabled: boolean;
-      /** Available in panel, nav routes for sidebar */
-      navigation: Navigation;
-      /** Dispatch facade backing the fixed /panel/[slug]/... and /api/[slug]/... routes */
-      routes: RouteHandlers;
-			/**
-			 * Current locale if applicable
-			 * set following this prioroty :
-			 * - locale inside the url from your front-end ex: /en/foo
-			 * - locale from searchParams ex : ?locale=en
-			 * - locale from cookie
-			 * - default locale
-			*/
-      locale: string | undefined;
-    }
-  }
-}`;
-    const content = [
-        ...(IS_RIME_REPO ? ['// eslint-disable-next-line no-restricted-imports'] : []),
-        `import '${PACKAGE_NAME}';`,
-        `import type { Session } from 'better-auth';`,
-        ...(IS_RIME_REPO ? ['// eslint-disable-next-line no-restricted-imports'] : []),
-        typeImports,
-        '',
-        relationValueType,
-        `declare global {`,
-        collectionsTypes,
-        areasTypes,
-        treeBlocksTypes.join('\n'),
-        blocksTypes.join('\n'),
-        hasBlocks ? blocksTypeNames : '',
-        hasBlocks ? anyBlock : '',
-        `}`,
-        locals,
-        templateRegister(config)
-    ].join('\n');
-    return content;
-}
-/**
- * Writes the generated types to the app.generated.d.ts file
- * @param content The string containing all type definitions
- */
-function write(key, content, filePath) {
-    const cachedTypes = cache.get(key);
-    if (cachedTypes && cachedTypes === content) {
-        return;
-    }
-    else {
-        cache.set(key, content);
-    }
-    const [error] = trycatchSync(() => fs.writeFileSync(filePath, content));
-    if (error) {
-        logger.error(error);
-    }
-}
-/**
- * Generates and writes TypeScript type definitions based on the built configuration
- * @param config The built configuration containing collections, areas, and fields
- */
-async function generateTypes(config) {
-    const mainTypes = await generateTypesString(config);
-    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);
-    write('rime.generated', declarations, virtualModuleGeneratedPath);
-}
-export default generateTypes;

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

@@ -1,308 +0,0 @@
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { RIME_DEV_CACHE_DIR } from '../../constant.server.js';
-import { ensureHasInit } from '../../ensure.server.js';
-import { logger } from '../../logger/index.server.js';
-import { getPackageInfoByKey } from '../cli/util/package.server.js';
-import { CONFIG_DIR, GENERATED_DIR, generatedConfigServerPath, isInstalledDependency, schemaPath } from '../constants.js';
-import { findInstalledPackageRoot, findModulePair, scanModulePairs } from '../generate/runtime/index.server.js';
-import { parseExportNames } from '../generate/runtime/parse-exports.server.js';
-import { sanitize } from '../generate/sanitize/index.server.js';
-const dev = process.env.NODE_ENV === 'development';
-/** Picks the client or server side of a module.(server.)ts pair. When the requested side
- *  wasn't authored (e.g. a collection's $url/$hooks, real only server-side, imported anyway by
- *  the isomorphic index.ts a client build also needs for its field definitions), stubs each of
- *  the *other* side's export names to `undefined` instead of returning nothing — ESM does
- *  static named-export binding, so an empty module isn't enough, `import { x } from ...` throws
- *  a SyntaxError at link time if `x` isn't actually exported, it doesn't lazily become
- *  `undefined`. Harmless: server-only exports are already stripped from client-side types, so
- *  nothing client-side ever reads the stubbed value — it only has to exist. */
-function exportFrom(entry, isServer) {
-    const target = isServer ? entry.server : entry.client;
-    if (target)
-        return `export * from '${target.replace(/\.ts$/, '.js')}';`;
-    const other = isServer ? entry.client : entry.server;
-    if (!other)
-        return '';
-    return parseExportNames(other)
-        .map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`)
-        .join('\n');
-}
-/** Splits `<pkg>/<subpath>` or `@scope/<pkg>/<subpath>` into its package name and the rest —
- *  a scoped name is two path segments, a plain one is one. */
-function splitPackageSpecifier(rest) {
-    const segments = rest.split('/');
-    const pkgName = rest.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];
-    const subpath = segments.slice(pkgName.split('/').length).join('/');
-    return { pkgName, subpath };
-}
-// Writes the local-dev $rime/modules barrel types from every module.(server.)ts pair under
-// src/lib. Exported so the CLI `generate` command can call it too — its Vite server runs in
-// middlewareMode, which never fires the `listening` event `rime()` normally hooks this to.
-export function regenerateModulesDeclaration() {
-    const libDir = path.resolve(process.cwd(), 'src/lib');
-    const pairs = scanModulePairs(libDir);
-    const exports = Array.from(pairs.values())
-        .map((entry) => entry.server || entry.client)
-        .filter(Boolean)
-        .map((file) => `$lib/${path.relative(libDir, file).split(path.sep).join('/')}`.replace(/\.ts$/, '.js'))
-        .map((aliased) => `  export * from '${aliased}';`)
-        .join('\n');
-    writeFileSync(path.resolve(process.cwd(), 'src/rime.modules.generated.d.ts'), `declare module '$rime/modules' {\n${exports}\n}\n`);
-}
-export function rime() {
-    /** Two reserved names, always resolved to *the currently running app's* generated
-     *  config/schema, independent of who's asking — a third-party plugin importing
-     *  `$rime/config` gets the host app's config, never its own. Unrelated to the modules
-     *  mechanism below (a package's own client/server split): different problem, same `$rime/`
-     *  namespace only by convention. */
-    const VCoreId = '$rime/config';
-    const VSchemaId = '$rime/schema';
-    /**
-     * `$rime/modules` lets a package split its code into client and server files.
-     *
-     * While developing, you can just write `$rime/modules` with no path and it scans this
-     * project's own `src/lib` for every split. Before the package is published, that gets
-     * rewritten into explicit imports like `$rime/modules/<pkg>/<path>` — so anyone installing
-     * the package never sees the bare form, only real paths.
-     *
-     * When resolving one of those explicit imports: if `<pkg>` is this same project, we read
-     * straight from `src/lib`. Otherwise it's a real dependency, so we find it in
-     * `node_modules` and read the file list it shipped.
-     *
-     */
-    const VModulesId = '$rime/modules';
-    const VModulesPrefix = '$rime/modules/';
-    const ownPackageName = getPackageInfoByKey('name');
-    // Separates a resolved root from the original specifier inside one virtual module id — never
-    // appears in a real path or a JS specifier, so it's an unambiguous split point. Only the
-    // third-party qualified-form case needs it (the root has to travel with the id since load()
-    // doesn't receive importer); the barrel and self-reference cases carry no baked-in root.
-    const ROOT_SEP = '\x01';
-    const resolvedVModule = (name) => '\0' + name;
-    return {
-        name: 'virtual-rime',
-        configureServer(server) {
-            // Add a listener for when the server starts
-            server.httpServer?.once('listening', () => {
-                dev && ensureHasInit();
-                regenerateModulesDeclaration();
-                // Check if we need to rebuild
-                const shouldRebuild = process.argv.includes('--rebuild');
-                if (shouldRebuild && existsSync(RIME_DEV_CACHE_DIR)) {
-                    rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
-                    logger.info('--rebuild : node_modules/.rime folder deleted');
-                }
-            });
-            // module.ts/module.server.ts appearing, changing, or disappearing under this project's
-            // own src/lib — regenerate the $rime/modules declaration above so the IDE picks up the
-            // new/changed/removed split immediately. Listens on add/unlink too, unlike the config
-            // watcher below (change-only) — a new split is exactly as likely to be a brand new file
-            // as an edit to an existing one.
-            const isModuleFile = (p) => /[/\\]module(\.server)?\.ts$/.test(p) &&
-                p.includes(`${path.sep}src${path.sep}lib${path.sep}`);
-            server.watcher.on('add', (p) => isModuleFile(p) && regenerateModulesDeclaration());
-            server.watcher.on('unlink', (p) => isModuleFile(p) && regenerateModulesDeclaration());
-            server.watcher.on('change', (p) => isModuleFile(p) && regenerateModulesDeclaration());
-            // Add a watcher for sanitizing config changes and triggering schema/routes/types
-            // generation. Debounced + single-flight: a config change is rarely one file (e.g. a
-            // plugin swap copying several files under +rime/ at once) — without this, each file
-            // fires its own overlapping sanitize()+generate()+migrate() run against the same db/
-            // and sqlite file, racing each other.
-            let reloadTimer = null;
-            let reloadInFlight = null;
-            let reloadQueued = false;
-            async function runConfigReload() {
-                if (reloadInFlight) {
-                    reloadQueued = true;
-                    return;
-                }
-                reloadInFlight = (async () => {
-                    // Sanitize the config client/server
-                    try {
-                        await sanitize();
-                    }
-                    catch (error) {
-                        logger.error('Error while sanitizing config:', error.message);
-                        return;
-                    }
-                    // Trigger generation
-                    try {
-                        // ssrLoadModule wants the real .ts file path, not a $lib/*.js-style import
-                        // specifier — different consumer than configImportPaths() (used for generated
-                        // source code).
-                        const mod = await server.ssrLoadModule(generatedConfigServerPath());
-                        // The config's default export is the createRime() promise; ssrLoadModule
-                        // only awaits the module's synchronous evaluation, so we must await it
-                        // directly to observe init errors (e.g. invalid config) here instead of
-                        // letting them become unhandled rejections that crash the dev server.
-                        await mod.default;
-                    }
-                    catch (error) {
-                        logger.error('Failed to reload the config', error.message);
-                    }
-                })();
-                await reloadInFlight;
-                reloadInFlight = null;
-                if (reloadQueued) {
-                    reloadQueued = false;
-                    await runConfigReload();
-                }
-            }
-            server.watcher.on('change', (modulePath) => {
-                const isConfigChange = modulePath.includes(CONFIG_DIR) && !modulePath.includes(GENERATED_DIR);
-                if (!isConfigChange)
-                    return;
-                if (reloadTimer)
-                    clearTimeout(reloadTimer);
-                reloadTimer = setTimeout(() => {
-                    reloadTimer = null;
-                    runConfigReload();
-                }, 150);
-            });
-        },
-        config() {
-            return {
-                ssr: {
-                    external: ['sharp']
-                },
-                optimizeDeps: {
-                    exclude: ['sharp'],
-                    include: ['@lucide/svelte']
-                },
-                build: {
-                    rollupOptions: {
-                        external: ['sharp']
-                    },
-                    target: 'es2022'
-                },
-                server: {
-                    watch: {
-                        ignored: ['**/db/**', '**/logs/**']
-                    }
-                }
-            };
-        },
-        async handleHotUpdate({ server, file }) {
-            function invalidateVModule(moduleId) {
-                const module = server.moduleGraph.getModuleById(resolvedVModule(moduleId));
-                if (module) {
-                    server.moduleGraph.invalidateModule(module);
-                    return module;
-                }
-                return null;
-            }
-            if (!isInstalledDependency(import.meta.url) && file.includes('src/lib/core/config')) {
-                logger.info('reload core config');
-                const module = invalidateVModule(VCoreId);
-                if (module)
-                    return [module];
-            }
-            if (/[/\\]module(\.server)?\.ts$/.test(file) &&
-                file.includes(`${path.sep}src${path.sep}lib${path.sep}`)) {
-                const module = invalidateVModule(VModulesId);
-                if (module)
-                    return [module];
-            }
-        },
-        resolveId(id, importer) {
-            if (id === VCoreId) {
-                return resolvedVModule(id);
-            }
-            if (id === VSchemaId) {
-                return resolvedVModule(id);
-            }
-            if (id === VModulesId) {
-                return resolvedVModule(id); // barrel, no root to bake in — load() always scans this project's own src/lib
-            }
-            if (id.startsWith(VModulesPrefix)) {
-                const { pkgName } = splitPackageSpecifier(id.slice(VModulesPrefix.length));
-                if (pkgName === ownPackageName) {
-                    return resolvedVModule(id); // self-reference: load() scans this project's own src/lib too
-                }
-                if (!importer) {
-                    throw new Error(`$rime/modules: '${id}' has no importer to resolve '${pkgName}' from`);
-                }
-                // Third-party dependency: find its installed root now, while `importer` is still
-                // available (load() doesn't receive it) — baked into the id via ROOT_SEP. Walks up
-                // node_modules directly (see findInstalledPackageRoot) rather than resolving through
-                // the package's own `exports` map — confirmed in practice that both `require.resolve`
-                // and `import.meta.resolve` gate on a condition set matching, and a package whose
-                // exports only declare conditions neither uses (rime's own included: `types`/`svelte`/
-                // `import`, no `require`/`default`) fails to resolve at all through either.
-                const pkgRoot = findInstalledPackageRoot(pkgName, path.dirname(importer));
-                return resolvedVModule(`${pkgRoot}${ROOT_SEP}${id}`);
-            }
-            return null;
-        },
-        async load(id) {
-            const isServer = this.environment?.config?.consumer === 'server';
-            if (id === resolvedVModule(VCoreId)) {
-                const corePath = isServer ? 'rimecms/config/server' : 'rimecms/config';
-                return `export * from '${corePath}';`;
-            }
-            if (id === resolvedVModule(VSchemaId) && isServer) {
-                // Mirrors write.server.ts (adapter-sqlite/generate-schema) — the adapter itself never
-                // needed to change for this, it already goes through this virtual module instead of a
-                // hardcoded path.
-                const schemaFilePath = schemaPath();
-                if (existsSync(schemaFilePath)) {
-                    const modulePath = schemaFilePath.replace('.ts', '.js');
-                    return `export * from '${modulePath}'; export { default } from '${modulePath}';`;
-                }
-            }
-            if (id === resolvedVModule(VModulesId)) {
-                // Dev-mode barrel — re-exports every module.(server.)ts pair found under this
-                // project's own src/lib, live. Never ships: prepack rewrites every '$rime/modules'
-                // import into a qualified one before publish, so this only ever runs during dev.
-                const pairs = scanModulePairs(path.resolve(process.cwd(), 'src/lib'));
-                return Array.from(pairs.values())
-                    .map((entry) => exportFrom(entry, isServer))
-                    .filter(Boolean)
-                    .join('\n');
-            }
-            // Self-reference qualified form — resolveId returned this bare, no root baked in
-            // (matches VModulesId's shape above): resolve directly off this project's own src/lib.
-            if (id.startsWith(resolvedVModule(VModulesPrefix))) {
-                const subpath = splitPackageSpecifier(id.slice(resolvedVModule(VModulesPrefix).length)).subpath;
-                const pair = findModulePair(path.resolve(process.cwd(), 'src/lib'), subpath);
-                if (!pair)
-                    throw new Error(`${id.slice(1)}: doesn't resolve under this project's own src/lib`);
-                return exportFrom(pair, isServer);
-            }
-            // Third-party qualified form — resolveId baked the resolved package root in via
-            // ROOT_SEP: read what it shipped at prepack, don't guess.
-            {
-                const modulesSepIndex = id.indexOf(ROOT_SEP);
-                const modulesSpecifier = modulesSepIndex === -1 ? '' : id.slice(modulesSepIndex + 1);
-                if (modulesSpecifier.startsWith(VModulesPrefix)) {
-                    const pkgRoot = id.slice(1, modulesSepIndex);
-                    const rest = modulesSpecifier.slice(VModulesPrefix.length);
-                    const { pkgName, subpath } = splitPackageSpecifier(rest);
-                    const distDir = path.join(pkgRoot, 'dist');
-                    const manifestPath = path.join(distDir, '.rime-modules.json');
-                    if (!existsSync(manifestPath)) {
-                        throw new Error(`$rime/modules/${pkgName}: no manifest at ${manifestPath} — does ${pkgName} run 'rime generate-manifest' at prepack?`);
-                    }
-                    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-                    const pair = manifest[subpath];
-                    if (!pair) {
-                        throw new Error(`$rime/modules/${pkgName}/${subpath}: not found in ${pkgName}'s manifest`);
-                    }
-                    // Manifest entries are stored relative to *that package's own* dist/ (written by
-                    // generate-manifest on whatever machine packed it) - re-rooted onto distDir (this
-                    // installed copy's real, resolved location) here, not trusted as absolute. An
-                    // absolute path baked in at pack time would silently read the package author's own
-                    // working-copy dist/ instead of what's actually installed here whenever both
-                    // happen to exist on the same machine (exactly what authoring rime itself hit).
-                    const resolvedPair = {
-                        client: pair.client ? path.join(distDir, pair.client) : '',
-                        server: pair.server ? path.join(distDir, pair.server) : ''
-                    };
-                    return exportFrom(resolvedPair, isServer);
-                }
-            }
-            return null;
-        }
-    };
-}