rimecms 0.30.3 → 0.31.0

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

@@ -1,36 +1,108 @@
 import dotenv from 'dotenv';
-import { existsSync, rmSync } from 'node:fs';
+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 { INPUT_DIR, isInstalledDependency, OUTPUT_DIR } from '../constants.js';
-import { buildRuntimeRegistry } from '../generate/runtime/index.server.js';
+import { getPackageInfoByKey } from '../cli/util/package.server.js';
+import { INPUT_DIR, isInstalledDependency, OUTPUT_DIR, 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';
 dotenv.config({ override: true });
 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 };
+}
 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';
-    /** Any field's client/server split: rime's own (relation/index.ts, link/index.ts) and a
-     *  consumer app's own local fields alike. `import { x } from '$rime/<name>'` resolves `<name>`
-     *  against a registry built once (see generate/runtime/index.server.ts's buildRuntimeRegistry,
-     *  which scans for `<name>/module.ts` + `module.server.ts` pairs) to either `module.server.ts`
-     *  (server builds) or `module.ts` (browser builds). The specifier is a static string baked into
-     *  the source, so it survives esbuild's dep-optimizer flattening — unlike an importer-relative
-     *  lookup, which breaks the moment the importing file gets pre-bundled (importer becomes the
-     *  flattened chunk, not the real source file). `config` and `schema` are reserved names (see
-     *  VCoreId/VSchemaId below, checked first) — a field can't be registered under either. */
-    const VPrefix = '$rime/';
+    /** `$rime/modules` — a package's own client/server split, resolved relative to *whoever's
+     *  asking*, always self-contained. Two forms:
+     *
+     *  - The bare barrel, `$rime/modules`, addressed by *export name* rather than path — dev
+     *    only, live-scans this project's own `src/lib` for every `module.(server.)ts` pair (see
+     *    `regenerateModulesDeclaration` below for the matching local-dev `.d.ts`). Never ships:
+     *    a prepack step (the `generate-manifest` CLI command) AST-rewrites every `$rime/modules`
+     *    import into the qualified form below before publish, so a consumer never sees the
+     *    barrel at all.
+     *  - The qualified form, `$rime/modules/<pkg>/<path>`, always package-qualified — even for a
+     *    package's own internal references to itself. Two ways it resolves, both in `resolveId`
+     *    (not `load`, which never receives `importer`): `<pkg>` equals this project's own
+     *    `package.json` name → self-reference, resolved directly off this project's own
+     *    `src/lib`. Otherwise → an installed dependency, its root found by walking up
+     *    `node_modules/<pkg>` from the importer's own directory (`findInstalledPackageRoot` —
+     *    pure directory existence, no `exports`-conditions matching, since a package whose
+     *    `exports` map declares only conditions neither `require.resolve` nor
+     *    `import.meta.resolve` use fails to resolve through either) and its shipped
+     *    `dist/.rime-modules.json` read directly — no directory-convention guessing beyond that,
+     *    immune to Vite's dep-optimizer flattening a package (reading a known filename off disk
+     *    never touches the import graph the optimizer rewrites). Full design:
+     *    docs/plans/imports.md. */
+    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;
-    let runtimeRegistry = null;
-    const getRuntimeRegistry = () => (runtimeRegistry ??= buildRuntimeRegistry());
+    // Local-dev types for the $rime/modules barrel — declares every module.(server.)ts pair
+    // currently under this project's own src/lib, live. Regenerated on startup and whenever a
+    // module file appears/changes/disappears (see the watcher below) — never ships, gitignored,
+    // same treatment as app.generated.d.ts/rime.generated.d.ts.
+    //
+    // $lib/-aliased paths, not bare relative/absolute ones — verified directly (a plain relative
+    // or absolute `export * from` inside a `declare module` block silently resolves to no
+    // exports at all; TS only picks up the re-exported names through a real configured alias).
+    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`);
+    }
     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)) {
@@ -38,11 +110,30 @@ export function rime() {
                     logger.info('--rebuild : node_modules/.rime folder deleted');
                 }
             });
-            // Add a watcher for sanitizing config changes
-            // and trigger schema/routes/types generation
-            server.watcher.on('change', async (modulePath) => {
-                if (modulePath.includes(`src/lib/${INPUT_DIR}`) &&
-                    !modulePath.includes(`src/lib/${OUTPUT_DIR}`)) {
+            // 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();
@@ -53,7 +144,11 @@ export function rime() {
                     }
                     // Trigger generation
                     try {
-                        const mod = await server.ssrLoadModule(`src/lib/${OUTPUT_DIR}/rime.config.server.ts`);
+                        // ssrLoadModule wants the real .ts file path, not a $lib/*.js-style import
+                        // specifier — different consumer than configImportPaths() (used for generated
+                        // source code), so computed directly here.
+                        const serverConfigPath = `src/lib/${OUTPUT_DIR}/rime.config.server.ts`;
+                        const mod = await server.ssrLoadModule(serverConfigPath);
                         // 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
@@ -63,7 +158,25 @@ export function rime() {
                     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(`src/lib/${INPUT_DIR}`) &&
+                    !modulePath.includes(`src/lib/${OUTPUT_DIR}`);
+                if (!isConfigChange)
+                    return;
+                if (reloadTimer)
+                    clearTimeout(reloadTimer);
+                reloadTimer = setTimeout(() => {
+                    reloadTimer = null;
+                    runConfigReload();
+                }, 150);
             });
         },
         config() {
@@ -106,43 +219,108 @@ export function rime() {
                 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) {
+        resolveId(id, importer) {
             if (id === VCoreId) {
                 return resolvedVModule(id);
             }
             if (id === VSchemaId) {
                 return resolvedVModule(id);
             }
-            if (id.startsWith(VPrefix)) {
-                const name = id.slice(VPrefix.length);
-                // Unregistered name: return null so it surfaces as a normal "failed to resolve
-                // import" error instead of a silent virtual-module 404.
-                if (!getRuntimeRegistry().has(name))
-                    return null;
-                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;
         },
-        load(id) {
+        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) {
-                const schemaPath = path.resolve(process.cwd(), `src/lib/${OUTPUT_DIR}/schema.server.ts`);
-                if (existsSync(schemaPath)) {
-                    const modulePath = schemaPath.replace('.ts', '.js');
+                // 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.startsWith(resolvedVModule(VPrefix))) {
-                const name = id.slice(resolvedVModule(VPrefix).length);
-                const entry = getRuntimeRegistry().get(name);
-                if (entry) {
-                    const target = (isServer ? entry.server : entry.client).replace(/\.ts$/, '.js');
-                    return `export * from '${target}';`;
+            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;

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

@@ -1,14 +1,15 @@
 import type { BuiltCollection } from '../types.js';
 /**
- * Ensure sanitize config exists
+ * Ensure sanitize config exists — the generated server config inside rime.generated/.
  */
 export declare function ensureGeneratedConfig(): string;
 /**
- * Ensure user config exists
+ * Ensure user config exists — the src/lib/+rime/ folder convention.
  */
 export declare function ensureUserConfigExist(): void;
 /**
- * Ensure schema exists
+ * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to
+ * the same path).
  */
 export declare function ensureSchema(): void;
 /**

package/dist/core/ensure.server.js

@@ -1,9 +1,9 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
-import { INPUT_DIR, OUTPUT_DIR } from './dev/constants.js';
+import { INPUT_DIR, OUTPUT_DIR, schemaPath } from './dev/constants.js';
 const projectRoot = process.cwd();
 /**
- * Ensure sanitize config exists
+ * Ensure sanitize config exists — the generated server config inside rime.generated/.
  */
 export function ensureGeneratedConfig() {
     const configGeneratedPath = path.resolve(projectRoot, 'src/lib', OUTPUT_DIR, 'rime.config.server.ts');
@@ -13,20 +13,20 @@ export function ensureGeneratedConfig() {
     return path.join('$lib', OUTPUT_DIR, 'rime.config.server.js');
 }
 /**
- * Ensure user config exists
+ * Ensure user config exists — the src/lib/+rime/ folder convention.
  */
 export function ensureUserConfigExist() {
-    const configPath = path.resolve(projectRoot, 'src/lib', INPUT_DIR, 'rime.config.ts');
-    if (!existsSync(configPath)) {
+    const folderConfig = path.resolve(projectRoot, 'src/lib', INPUT_DIR, 'rime.config.server.ts');
+    if (!existsSync(folderConfig)) {
         throw new Error('Unable to find config, did you run rime init');
     }
 }
 /**
- * Ensure schema exists
+ * Ensure schema exists (see adapter-sqlite/generate-schema/write.server.ts, which writes to
+ * the same path).
  */
 export function ensureSchema() {
-    const schemaPath = path.resolve(projectRoot, 'src/lib', OUTPUT_DIR, 'schema.server.ts');
-    if (!existsSync(schemaPath)) {
+    if (!existsSync(schemaPath(projectRoot))) {
         throw new Error('Unable to find schema, did you run rime init');
     }
 }

package/dist/core/handlers/index.js

@@ -10,7 +10,7 @@ export default async function (rime) {
         createCMSHandler(await rime),
         handleAuth,
         handleCORS,
-        handleRoutes,
-        ...createPluginsHandler(await rime)
+        ...createPluginsHandler(await rime),
+        handleRoutes
     ];
 }

package/dist/core/operations/hooks/before-upsert/data-config-map.server.d.ts

@@ -1 +1 @@
-export declare const buildDataConfigMap: import("../index.server.js").Hook<"raw", "update" | "create", "before">;
+export declare const buildDataConfigMap: import("../index.server.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/operations/hooks/before-upsert/handle-new-version.server.d.ts

@@ -2,4 +2,4 @@
  * Handles version-related operations for document updates
  * Manages specific version updates and new version creation
  */
-export declare const handleNewVersion: import("../index.server.js").Hook<"raw", "update" | "create", "before">;
+export declare const handleNewVersion: import("../index.server.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/operations/hooks/before-upsert/original-config-map.server.d.ts

@@ -1 +1 @@
-export declare const buildOriginalDocConfigMap: import("../index.server.js").Hook<"raw", "update" | "create", "before">;
+export declare const buildOriginalDocConfigMap: import("../index.server.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/operations/hooks/before-upsert/set-default-values.server.d.ts

@@ -1,6 +1,6 @@
 import type { Adapter } from '../../../../adapter-sqlite/index.server.js';
 import type { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
-export declare const setDefaultValues: import("../index.server.js").Hook<"raw", "update" | "create", "before">;
+export declare const setDefaultValues: import("../index.server.js").Hook<"raw", "create" | "update", "before">;
 type GetDefaultValue = (args: {
     key: string;
     config: FormFieldBuilder;

package/dist/core/operations/hooks/before-upsert/validate-fields.server.d.ts

@@ -1 +1 @@
-export declare const validateFields: import("../index.server.js").Hook<"raw", "update" | "create", "before">;
+export declare const validateFields: import("../index.server.js").Hook<"raw", "create" | "update", "before">;

package/dist/core/operations/hooks/index.server.d.ts

@@ -81,10 +81,6 @@ export declare const Hooks: {
      * Creates a before delete hook
      */
     beforeDelete: <S extends DocType = "raw">(handler: Hook<S, "delete", "before">) => Hook<S, "delete", "before">;
-    /**
-     * Creates an after read hook
-     */
-    afterRead: <S extends DocType = "raw">(handler: Hook<S, "read", "after">) => Hook<S, "read", "after">;
     /**
      * Creates an after create hook
      */

package/dist/core/operations/hooks/index.server.js

@@ -26,10 +26,6 @@ export const Hooks = {
      * Creates a before delete hook
      */
     beforeDelete: (handler) => handler,
-    /**
-     * Creates an after read hook
-     */
-    afterRead: (handler) => handler,
     /**
      * Creates an after create hook
      */

package/dist/core/plugins/api-init/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../../.rime-modules.d.ts" />
+export { apiInit } from "$rime/modules/rimecms/core/plugins/api-init";

package/dist/core/plugins/api-init/index.js

@@ -0,0 +1 @@
+export { apiInit } from "$rime/modules/rimecms/core/plugins/api-init";

package/dist/core/plugins/api-init/{index.server.d.ts → module.server.d.ts}

@@ -1,7 +1,6 @@
 import { type RequestHandler } from '@sveltejs/kit';
 export declare const apiInit: () => {
     readonly name: "apiInit";
-    readonly type: "server";
     readonly routes: {
         readonly '/api/init': {
             readonly POST: RequestHandler;

package/dist/core/plugins/api-init/{index.server.js → module.server.js}

@@ -46,7 +46,6 @@ export const apiInit = definePlugin(() => {
     };
     return {
         name: 'apiInit',
-        type: 'server',
         routes: {
             '/api/init': {
                 POST: requestHandler

package/dist/core/plugins/cache/index.d.ts

@@ -1,5 +1,2 @@
-export declare const cacheClient: () => {
-    readonly name: "cache/client";
-    readonly type: "client";
-    readonly configure: <const C extends import("../../config/types.js").SanitizedConfigClient>(config: C) => C;
-};
+/// <reference path="../../../.rime-modules.d.ts" />
+export { cache } from "$rime/modules/rimecms/core/plugins/cache";

package/dist/core/plugins/cache/index.js

@@ -1,21 +1 @@
-import { definePluginClient } from '../index.js';
-import HeaderButton from './HeaderButton.svelte';
-export const cacheClient = definePluginClient(() => {
-    return {
-        name: 'cache/client',
-        type: 'client',
-        configure: (config) => {
-            config = {
-                ...config,
-                panel: {
-                    ...(config.panel || {}),
-                    components: {
-                        ...(config.panel?.components || { header: [], collectionHeader: [] }),
-                        header: [...(config.panel?.components?.header || []), HeaderButton]
-                    }
-                }
-            };
-            return config;
-        }
-    };
-});
+export { cache } from "$rime/modules/rimecms/core/plugins/cache";

package/dist/core/plugins/cache/module.d.ts

@@ -0,0 +1,4 @@
+export declare const cache: () => {
+    readonly name: "cache";
+    readonly configure: <const C extends import("../../config/types.js").Config | import("../../config/types.js").SanitizedConfigClient>(config: C) => C;
+};

package/dist/core/plugins/cache/module.js

@@ -0,0 +1,22 @@
+import { definePlugin } from '../index.js';
+import HeaderButton from './HeaderButton.svelte';
+// Signature has to match module.server.ts's — the same call site (whatever the consumer
+// wrote in rime.config.ts) compiles against both, whichever one this build resolves to.
+export const cache = definePlugin(() => {
+    return {
+        name: 'cache',
+        configure: (config) => {
+            config = {
+                ...config,
+                panel: {
+                    ...(config.panel || {}),
+                    components: {
+                        ...(config.panel?.components || { header: [], collectionHeader: [] }),
+                        header: [...(config.panel?.components?.header || []), HeaderButton]
+                    }
+                }
+            };
+            return config;
+        }
+    };
+});

package/dist/core/plugins/cache/{index.server.d.ts → module.server.d.ts}

@@ -26,8 +26,7 @@ type CacheOptions = {
 export declare const toHash: (str: string) => string;
 export declare const cache: (options?: CacheOptions) => {
     readonly name: "cache";
-    readonly type: "server";
-    readonly configure: <const C extends import("../../config/types.js").Config>(config: C) => C;
+    readonly configure: <const C extends import("../../config/types.js").Config | import("../../config/types.js").SanitizedConfigClient>(config: C) => C;
     readonly routes: {
         readonly '/api/clear-cache': {
             readonly POST: () => Response;

package/dist/core/plugins/cache/{index.server.js → module.server.js}

@@ -45,7 +45,6 @@ export const cache = definePlugin((options) => {
     };
     return {
         name: 'cache',
-        type: 'server',
         configure: (config) => {
             config = {
                 ...config,

package/dist/core/plugins/index.d.ts

@@ -2,19 +2,12 @@ import type { Config, RouteConfig } from '../../types.js';
 import type { Handle } from '@sveltejs/kit';
 import type { SanitizedConfigClient } from '../config/types.js';
 type MaybeAsyncFunction = (...args: any[]) => any | Promise<any>;
-export type PluginClient = {
-    name: string;
-    type: 'client';
-    configure?: <const C extends SanitizedConfigClient>(config: C) => C;
-};
 export type Plugin = {
     name: string;
-    type: 'server';
-    configure?: <const C extends Config>(config: C) => C;
+    configure?: <const C extends Config | SanitizedConfigClient>(config: C) => C;
     actions?: Record<string, MaybeAsyncFunction>;
     routes?: Record<string, RouteConfig>;
     handler?: Handle;
 };
 export declare function definePlugin<const F extends (options?: any) => Plugin>(factory: F): F;
-export declare function definePluginClient<const F extends (options?: any) => PluginClient>(factory: F): F;
 export {};

package/dist/core/plugins/index.js

@@ -1,6 +1,3 @@
 export function definePlugin(factory) {
     return factory;
 }
-export function definePluginClient(factory) {
-    return factory;
-}

package/dist/core/plugins/mailer/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../../.rime-modules.d.ts" />
+export { mailer } from "$rime/modules/rimecms/core/plugins/mailer";

package/dist/core/plugins/mailer/index.js

@@ -0,0 +1 @@
+export { mailer } from "$rime/modules/rimecms/core/plugins/mailer";

package/dist/core/plugins/mailer/{index.server.d.ts → module.server.d.ts}

@@ -1,7 +1,6 @@
 import type SMTPTransport from 'nodemailer/lib/smtp-transport';
 export declare const mailer: (smtpConfig: SMTPConfig) => {
     readonly name: "mailer";
-    readonly type: "server";
     readonly actions: {
         readonly sendMail: (args: {
             to: string;

package/dist/core/plugins/mailer/{index.server.js → module.server.js}

@@ -25,7 +25,6 @@ export const mailer = definePlugin((smtpConfig) => {
     };
     return {
         name: 'mailer',
-        type: 'server',
         actions: {
             sendMail
         }

package/dist/core/plugins/sse/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../../.rime-modules.d.ts" />
+export { sse } from "$rime/modules/rimecms/core/plugins/sse";

package/dist/core/plugins/sse/index.js

@@ -0,0 +1 @@
+export { sse } from "$rime/modules/rimecms/core/plugins/sse";