rimecms 0.31.4 → 0.32.0

package/dist/core/boot.server.js

@@ -0,0 +1,61 @@
+import { dev } from '$app/environment';
+import { createAuthInstance } from './auth/better-auth/instance.server.js';
+import { bootUpload } from './prototype/collection/upload/boot/index.server.js';
+import { createConfigContext } from './config/context.server.js';
+import i18n from './i18n/index.js';
+import { registerTranslation } from './i18n/register.server.js';
+import { area } from './prototype/area/definition.server.js';
+/**
+ * Phase 2 of three — everything that happens once, when the process starts.
+ *
+ * A numbered sequence rather than a list of uniform steps, because each one feeds the next: the
+ * config context feeds the adapter, the adapter feeds better-auth. Two of those dependencies —
+ * schema before adapter, adapter before better-auth — are load-bearing and invisible anywhere
+ * else, which is why the order is written out.
+ */
+export const bootRime = async (config) => {
+    // 1. Plugins, flattened to a name -> actions map. First because codegen and better-auth both
+    //    read it (the mailer plugin supplies better-auth's transport).
+    const plugins = Object.fromEntries(config.plugins.map((plugin) => [plugin.name, plugin.actions ?? {}])
+    // Named as `BuildConfig<C>['$InferPluginsServer']`, the same way `Rime` declares it, so the
+    // two agree. `typeof config.$InferPluginsServer` looks equivalent and is not: indexing the
+    // built config picks up `C`'s own `$InferPluginsServer` in the intersection too.
+    );
+    // 2. The config interface — every lookup by slug, the locale list, the raw config.
+    const configCtx = createConfigContext(config);
+    // 3. Upload makes sure the static directory it writes into exists.
+    bootUpload(config);
+    // 4. Phase 1, in dev only: write routes, schema and types. Before the adapter, which imports
+    //    the schema this produces.
+    if (dev) {
+        const runCodegen = await import('./codegen.server.js').then((m) => m.runCodegen);
+        await runCodegen({ config, generateSchema: config.$adapter.generateSchema });
+    }
+    // 5. The database. Consumes the schema generated in step 4.
+    const adapter = await config.$adapter.createAdapter(configCtx);
+    // 6. Register every prototype config with the adapter. It reads `config.type` and builds a
+    //    collection handle or an area handle; `adapter.collection(slug)` and `adapter.area(slug)`
+    //    serve them from then on.
+    //
+    //    The first step here that touches the database, deliberately: a prototype whose tables are
+    //    missing fails at boot, naming itself, instead of on whichever request first reaches it.
+    for (const prototypeConfig of [...config.collections, ...config.areas]) {
+        adapter.registerPrototype(prototypeConfig);
+    }
+    // 7. An area's row has to exist before a request can read it, so `boot` writes it. A collection
+    //    has none: nothing needs to be there before the first create.
+    for (const areaConfig of config.areas) {
+        await area.boot?.({
+            config: areaConfig,
+            adapter,
+            defaultLocale: configCtx.getDefaultLocale()
+        });
+    }
+    // 8. FEATURE (auth): better-auth. After the adapter, whose betterAuthAdapter it stores into.
+    //    The instance is built in its own module so `RimeContext` can name its *type* without
+    //    naming this one.
+    const auth = createAuthInstance({ config, configCtx, mailer: plugins.mailer, adapter });
+    // 9. Panel translations, for the configured language.
+    i18n.init(await registerTranslation(config.panel.language));
+    return { plugins, configCtx, adapter, auth };
+};

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

@@ -0,0 +1,22 @@
+import type { Config } from './config/types.js';
+import type { BuildConfig } from './config/index.server.js';
+/**
+ * Phase 1 of three — everything rime writes to disk, in the order it writes it.
+ *
+ * This is to a build what pipeline.server.ts is to a request: the one place the sequence is
+ * written down. Unlike the hook pipeline it cannot be a flat array, because each step's output
+ * is the next step's input on disk — drizzle.config.ts must be current before generateSchema
+ * shells out to drizzle-kit, which reads it straight off the filesystem.
+ *
+ * Runs *inside* boot, and only under `dev`. That is deliberate, not a leftover: in development
+ * codegen is on the fly — editing a collection invalidates the config module, the app reboots,
+ * and this runs again as part of that reload. There is no separate codegen program, and
+ * `rime generate` is simply a boot in a throwaway Vite server (dev/cli/commands/generate.server.ts).
+ *
+ * A consequence of that design: two processes can be in this phase at once — a running dev
+ * server and a CLI invocation — both writing the same directories. Hence the guard below.
+ */
+export declare const runCodegen: <const C extends Config>(args: {
+    config: BuildConfig<C>;
+    generateSchema: (config: BuildConfig<C>) => Promise<void>;
+}) => Promise<void>;

package/dist/core/codegen.server.js

@@ -0,0 +1,58 @@
+import devCache from './dev/cache.server.js';
+import { regenerateDrizzleConfig, regenerateHooks } from './dev/cli/templates/init.js';
+import generateRoutes from './dev/codegen/routes/index.server.js';
+import generateTypes from './dev/codegen/types/index.server.js';
+import { RimeError } from './errors/index.js';
+import validate from './config/validate.server.js';
+import writeMemo from './dev/config-memo.server.js';
+import { logger } from './logger.server.js';
+/**
+ * Phase 1 of three — everything rime writes to disk, in the order it writes it.
+ *
+ * This is to a build what pipeline.server.ts is to a request: the one place the sequence is
+ * written down. Unlike the hook pipeline it cannot be a flat array, because each step's output
+ * is the next step's input on disk — drizzle.config.ts must be current before generateSchema
+ * shells out to drizzle-kit, which reads it straight off the filesystem.
+ *
+ * Runs *inside* boot, and only under `dev`. That is deliberate, not a leftover: in development
+ * codegen is on the fly — editing a collection invalidates the config module, the app reboots,
+ * and this runs again as part of that reload. There is no separate codegen program, and
+ * `rime generate` is simply a boot in a throwaway Vite server (dev/cli/commands/generate.server.ts).
+ *
+ * A consequence of that design: two processes can be in this phase at once — a running dev
+ * server and a CLI invocation — both writing the same directories. Hence the guard below.
+ */
+export const runCodegen = async (args) => {
+    const { config, generateSchema } = args;
+    // A `rime generate` CLI run may be regenerating the same .rime cache concurrently (e.g. a
+    // running dev server reloading off the CLI's file writes). Skip our own generation this cycle
+    // rather than racing it or blocking this request on it — the next natural reload picks up
+    // whatever the CLI produced.
+    if (process.env.RIME_CLI !== 'true' && devCache.get('.cli')) {
+        logger.debug('Skipping generation, `rime generate` is already running');
+        return;
+    }
+    // 1. Has anything changed since the last run? Everything below is skipped if not.
+    const changed = writeMemo(config);
+    // 2. Reject a config that cannot produce a coherent schema, before writing any of it.
+    if (!validate(config)) {
+        throw new RimeError('Config not valid');
+    }
+    if (!changed) {
+        logger.debug('Nothing to generate');
+        return;
+    }
+    // 3. SvelteKit routes — the (rime) panel tree and /api, plus the param matchers.
+    generateRoutes(config);
+    // 4. drizzle.config.ts, before generateSchema: it shells out to drizzle-kit generate/migrate,
+    //    which read the schema path straight off disk — stale here means the wrong (or missing)
+    //    schema file.
+    regenerateDrizzleConfig();
+    // 5. The drizzle schema. Owned by the adapter, which is why it arrives as an argument: this
+    //    is the one codegen step rime does not implement itself.
+    await generateSchema(config);
+    // 6. app.generated.d.ts — the types that carry collection and area slugs into consumer code.
+    await generateTypes(config);
+    // 7. src/hooks.server.ts, if the consumer has not written one.
+    regenerateHooks();
+};

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

@@ -0,0 +1,23 @@
+import type { BuiltArea, BuiltCollection, SanitizedConfigClient } from './types.js';
+/**
+ * Both prototype lists exist, empty if the author named none, so nothing downstream guards them.
+ *
+ * Was two `configure` props on the definitions, folded by `configureWithPrototypes`, with the
+ * result's *type* declared through a `PrototypeConfigure` merging target and replayed by a
+ * recursive `ApplyPrototypeConfigure`. Three mechanisms for two `?? []`, and the type they
+ * produced is the one an object literal infers on its own.
+ */
+export declare const withPrototypeLists: <T extends {
+    collections?: BuiltCollection[];
+    areas?: BuiltArea[];
+}>(config: T) => T & {
+    collections: BuiltCollection[];
+    areas: BuiltArea[];
+};
+/** The client chain, same three layers as build.server.ts — see the note there. */
+export declare const buildConfigClient: <C extends SanitizedConfigClient>(config: C) => C & {
+    collections: BuiltCollection[];
+    areas: BuiltArea[];
+} & Pick<import("./types.js").BuiltConfig, "panel" | "$trustedOrigins" | "$tables" | "icons"> & {
+    readonly plugins: import("../plugins/index.js").Plugin[];
+};

package/dist/core/config/build.js

@@ -0,0 +1,22 @@
+import { configureConfig } from './configure.js';
+import { configurePlugins } from '../plugins/configure.js';
+/**
+ * Both prototype lists exist, empty if the author named none, so nothing downstream guards them.
+ *
+ * Was two `configure` props on the definitions, folded by `configureWithPrototypes`, with the
+ * result's *type* declared through a `PrototypeConfigure` merging target and replayed by a
+ * recursive `ApplyPrototypeConfigure`. Three mechanisms for two `?? []`, and the type they
+ * produced is the one an object literal infers on its own.
+ */
+export const withPrototypeLists = (config) => ({
+    ...config,
+    collections: config.collections ?? [],
+    areas: config.areas ?? []
+});
+/** The client chain, same three layers as build.server.ts — see the note there. */
+export const buildConfigClient = (config) => {
+    const withLists = withPrototypeLists(config);
+    const configured = configureConfig(withLists);
+    const output = configurePlugins(configured);
+    return output;
+};

package/dist/core/config/build.server.d.ts

@@ -0,0 +1,70 @@
+import type { SMTPConfig } from '../plugins/mailer/index.server.js';
+import { type Rime } from '../rime.server.js';
+import type { Config } from './types.js';
+export declare const buildConfig: <const C extends Config>(config: C) => Promise<Rime<C>>;
+/**
+ * The config chain, one named step at a time:
+ *
+ * 1. `withPrototypeLists` — `collections` and `areas` exist, empty if the author named none.
+ * 2. `configureConfig` — the five whole-config steps, in `config/configure.ts`.
+ * 3. `configurePlugins` — the plugin layer, which can add collections of its own.
+ * 4. `resolvePipelines` — every prototype config's `$hooks`, last.
+ *
+ * A literal sequence rather than a loop, which `inference.spec.ts` guards: the narrowing at each
+ * step is what carries the slug literals through to `event.locals.rime`.
+ */
+declare function augmentConfig<T extends Config>(config: T): T & {
+    collections: import("./types.js").BuiltCollection[];
+    areas: import("./types.js").BuiltArea[];
+} & Pick<import("./types.js").BuiltConfig, "panel" | "$trustedOrigins" | "$tables" | "icons"> & {
+    readonly plugins: import("../plugins/index.js").Plugin[];
+};
+type InferCollections<C> = C extends {
+    collections?: readonly any[];
+} ? {
+    [K in NonNullable<C['collections']>[number] as K extends {
+        slug: infer N;
+    } ? N extends string ? N : never : never]: K;
+} : Record<string, never>;
+type InferAreas<C> = C extends {
+    areas?: readonly any[];
+} ? {
+    [K in NonNullable<C['areas']>[number] as K extends {
+        slug: infer N;
+    } ? N extends string ? N : never : never]: K;
+} : Record<string, never>;
+type InferCollectionsSlug<C> = C extends {
+    collections?: readonly any[];
+} ? NonNullable<C['collections']>[number] extends {
+    slug: infer N;
+} ? N extends string ? N : never : never : Array<never>;
+type InferAreasSlug<C> = C extends {
+    areas?: readonly any[];
+} ? NonNullable<C['areas']>[number] extends {
+    slug: infer N;
+} ? N extends string ? N : never : never : Array<never>;
+type InferCorePlugins<C extends Config> = {
+    cache: import('../plugins/cache/module.server.js').CacheActions;
+    sse: import('../plugins/sse/index.server.js').SSEActions;
+} & (C['$smtp'] extends SMTPConfig ? {
+    mailer: import('../plugins/mailer/index.server.js').MailerActions;
+} : Record<string, never>);
+type ExtractCustomPlugins<C> = C extends {
+    plugins: readonly (infer P)[];
+} ? P extends {
+    name: infer N;
+    actions?: infer A;
+} ? N extends string ? Record<N, NonNullable<A>> : never : never : Record<string, never>;
+type InferPluginsServer<C extends Config> = InferCorePlugins<C> & ExtractCustomPlugins<C>;
+export type BuildConfig<C extends Config = Config> = ReturnType<typeof augmentConfig<C>> & {
+    readonly $InferAuthPlugins: C['$auth'] extends {
+        plugins: any;
+    } ? C['$auth']['plugins'] : [];
+    readonly $InferRoutes: C['$routes'] extends Record<string, any> ? C['$routes'] : unknown;
+    readonly $InferPluginsServer: InferPluginsServer<C>;
+    readonly $InferCollections: InferCollections<C>;
+    readonly $InferAreas: InferAreas<C>;
+    readonly $InferAreasSlug: InferAreasSlug<C>;
+    readonly $InferCollectionsSlug: InferCollectionsSlug<C>;
+};
+export {};

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

@@ -0,0 +1,33 @@
+import { configureConfig } from './configure.js';
+import { withPrototypeLists } from './build.js';
+import { resolvePipelines } from '../pipeline/build.server.js';
+import { createRime } from '../rime.server.js';
+import { configurePlugins } from '../plugins/configure.js';
+export const buildConfig = (config) => {
+    const output = augmentConfig(config);
+    return createRime(output);
+};
+/**
+ * The config chain, one named step at a time:
+ *
+ * 1. `withPrototypeLists` — `collections` and `areas` exist, empty if the author named none.
+ * 2. `configureConfig` — the five whole-config steps, in `config/configure.ts`.
+ * 3. `configurePlugins` — the plugin layer, which can add collections of its own.
+ * 4. `resolvePipelines` — every prototype config's `$hooks`, last.
+ *
+ * A literal sequence rather than a loop, which `inference.spec.ts` guards: the narrowing at each
+ * step is what carries the slug literals through to `event.locals.rime`.
+ */
+function augmentConfig(config) {
+    const withLists = withPrototypeLists(config);
+    const configured = configureConfig(withLists);
+    const withPlugins = configurePlugins(configured);
+    // Last, so *every* prototype config gets its pipeline from the same line — authored, derived by
+    // a feature, or added by a plugin. A plugin's own collection used to arrive after this ran and
+    // so carried no pipeline at all: its first create failed on `missing configMap @create`.
+    //
+    // A plugin appending to a collection's `$hooks` still lands where it should — `buildPipeline`
+    // reads `$hooks` as the consumer layer and appends it after the placed hooks either way.
+    const output = resolvePipelines(withPlugins);
+    return output;
+}

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

@@ -0,0 +1,26 @@
+import type { BuiltConfig } from './types.js';
+import type { Dic } from '../../util/types.js';
+/**
+ * Everything that shapes the **whole** config, in the order it runs.
+ *
+ * The twin of a prototype's `augments` list, at the other scope: an augment shapes one prototype
+ * config, these five shape the config itself. It was `configureWithFeatures`, folding a
+ * deduplicated feature list and calling `feature.configure` on whatever declared one — so reading
+ * this order meant opening ten files and working out which of them had the prop.
+ *
+ * The order is the one the prototypes' feature lists produced, and two steps depend on it:
+ *
+ * - **staff before panel.** The panel's icon map covers the collections that exist when it runs,
+ *   and `staff` has to be one of them.
+ * - **panel before upload and versions.** Those two *derive* collections — `<slug>Directories`,
+ *   `$<slug>__versions` — and a derived collection has no place in the panel's navigation.
+ *
+ * Four of the six come through `$rime/modules`: they are server-only, and resolve to `undefined`
+ * on a client build, where nothing derives a collection. That is what the `step ? … : current`
+ * guard is for — the same one the fold made with `feature.configure ? … : current`.
+ *
+ * The type is declared rather than inferred, and that is load-bearing. `bootRime<C>` reads
+ * `config.panel.language` while `C` is still a type parameter; an intersection built from a key
+ * union stays deferred there and `panel` never resolves. A concrete `Pick` is decidable at once.
+ */
+export declare const configureConfig: <T extends Dic>(config: T) => T & Pick<BuiltConfig, "panel" | "icons" | "$trustedOrigins" | "$tables">;

package/dist/core/config/configure.js

@@ -0,0 +1,40 @@
+import { configureCors } from 'rimecms/core/cors/module';
+import { configureStaff } from 'rimecms/core/auth/module';
+import { configureUploadDirectories } from 'rimecms/core/prototype/collection/upload/module';
+import { configureVersions } from 'rimecms/core/prototype/shared/versions/module';
+import { configureAuthTables } from '../auth/configure.js';
+import { configurePanel } from '../panel/configure.js';
+/**
+ * Everything that shapes the **whole** config, in the order it runs.
+ *
+ * The twin of a prototype's `augments` list, at the other scope: an augment shapes one prototype
+ * config, these five shape the config itself. It was `configureWithFeatures`, folding a
+ * deduplicated feature list and calling `feature.configure` on whatever declared one — so reading
+ * this order meant opening ten files and working out which of them had the prop.
+ *
+ * The order is the one the prototypes' feature lists produced, and two steps depend on it:
+ *
+ * - **staff before panel.** The panel's icon map covers the collections that exist when it runs,
+ *   and `staff` has to be one of them.
+ * - **panel before upload and versions.** Those two *derive* collections — `<slug>Directories`,
+ *   `$<slug>__versions` — and a derived collection has no place in the panel's navigation.
+ *
+ * Four of the six come through `$rime/modules`: they are server-only, and resolve to `undefined`
+ * on a client build, where nothing derives a collection. That is what the `step ? … : current`
+ * guard is for — the same one the fold made with `feature.configure ? … : current`.
+ *
+ * The type is declared rather than inferred, and that is load-bearing. `bootRime<C>` reads
+ * `config.panel.language` while `C` is still a type parameter; an intersection built from a key
+ * union stays deferred there and `panel` never resolves. A concrete `Pick` is decidable at once.
+ */
+export const configureConfig = (config) => [
+    configureStaff,
+    configureAuthTables,
+    configurePanel,
+    configureUploadDirectories,
+    configureVersions,
+    configureCors
+].reduce(
+// `any` for the same reason a prototype's augments list is: each step names the shape it
+// needs, and a list holding several cannot promise any of them that shape.
+(current, step) => (step ? step(current) : current), config);

package/dist/core/config/context.server.d.ts

@@ -0,0 +1,82 @@
+import type { AreaSlug, CollectionSlug, Config, PrototypeSlug } from '../../types.js';
+import type { BuildConfig } from './build.server.js';
+/**
+ * What `event.locals.rime.config` is.
+ *
+ * Declared here, beside the function it is derived from, so that naming this type does not mean
+ * importing rime.server.js: `createAuthInstance` needs the name, and reaching for it there closes
+ * a `rime.server → boot.server → instance.server` cycle.
+ */
+export type ConfigContext<C extends Config = Config> = ReturnType<typeof createConfigContext<C>>;
+/**
+ * Object passed to the locals.rime to access the configuration in the server context
+ * it is created once on server start and can be used in any server context (load, actions, hooks, etc) via `event.locals.rime.config`
+ *
+ * @example
+ * ```ts
+ * // In +page.server.ts
+ * const config = event.locals.rime.config.raw;
+ * ```
+ */
+export declare function createConfigContext<const C extends Config>(config: BuildConfig<C>): {
+    /**
+     * Gets raw config object
+     */
+    readonly raw: BuildConfig<C>;
+    /**
+     * Gets all collections config
+     */
+    readonly collections: C extends {
+        collections?: readonly any[];
+    } ? { [K in NonNullable<C["collections"]>[number] as K extends {
+        slug: infer N;
+    } ? N extends string ? N : never : never]: K; } : Record<string, never>;
+    /**
+     * Gets all areas config
+     */
+    readonly areas: C extends {
+        areas?: readonly any[];
+    } ? { [K in NonNullable<C["areas"]>[number] as K extends {
+        slug: infer N;
+    } ? N extends string ? N : never : never]: K; } : Record<string, never>;
+    /**
+     * Gets every built prototype config, whatever its kind
+     */
+    readonly prototypes: (import("../../types.js").BuiltCollection | import("../../types.js").BuiltArea)[];
+    /**
+     * Gets the default locale from the configuration
+     */
+    getDefaultLocale(): string | undefined;
+    /**
+     * Gets all configured locale codes
+     */
+    getLocalesCodes: () => string[];
+    /**
+     * Checks if a locale code is valid according to the configuration
+     */
+    isValidLocale: (locale: string) => boolean;
+    /**
+     * Retrieves an area configuration by its slug
+     */
+    getArea: (slug: string) => import("../../types.js").BuiltArea;
+    /**
+     * Retrieves a collection configuration by its slug
+     */
+    getCollection: (slug: string) => import("../../types.js").BuiltCollection;
+    /**
+     * Retrieves either an area or collection configuration by its slug
+     */
+    getBySlug: (slug: string) => import("../../types.js").BuiltCollection | import("../../types.js").BuiltArea;
+    /**
+     * Checks if a slug represents a collection
+     */
+    isCollection: (slug?: string) => slug is CollectionSlug;
+    /**
+     * Checks if a slug represents an area
+     */
+    isArea: (slug?: string) => slug is AreaSlug;
+    /**
+     * Determines the prototype (collection or area) of a document by its slug
+     */
+    getDocumentPrototype(slug: PrototypeSlug): "area" | "collection";
+};

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

@@ -0,0 +1,118 @@
+import { RimeError } from '../errors/index.js';
+/**
+ * Object passed to the locals.rime to access the configuration in the server context
+ * it is created once on server start and can be used in any server context (load, actions, hooks, etc) via `event.locals.rime.config`
+ *
+ * @example
+ * ```ts
+ * // In +page.server.ts
+ * const config = event.locals.rime.config.raw;
+ * ```
+ */
+export function createConfigContext(config) {
+    const mapCollections = Object.fromEntries(config.collections.map((c) => [c.slug, c]));
+    const mapCollectionsSlug = config.collections.map((c) => c.slug);
+    const mapAreas = Object.fromEntries(config.areas.map((a) => [a.slug, a]));
+    const mapAreasSlug = config.areas.map((a) => a.slug);
+    /** Every built prototype config, whatever its kind. */
+    const allPrototypes = [...config.collections, ...config.areas];
+    const getLocalesCodes = () => config.localization ? config.localization.locales.map((l) => l.code) : [];
+    const isValidLocale = (locale) => getLocalesCodes().includes(locale);
+    const getArea = (slug) => {
+        const areaConfig = (config.areas || []).find((g) => g.slug === slug);
+        if (!areaConfig)
+            throw new RimeError(RimeError.BAD_REQUEST, `${slug} is not an area`);
+        return areaConfig;
+    };
+    const getCollection = (slug) => {
+        const collectionConfig = (config.collections || []).find((c) => c.slug === slug);
+        if (!collectionConfig)
+            throw new RimeError(RimeError.BAD_REQUEST, `${slug} is not a collection`);
+        return collectionConfig;
+    };
+    const getBySlug = (slug) => {
+        try {
+            return getCollection(slug);
+        }
+        catch {
+            try {
+                return getArea(slug);
+            }
+            catch {
+                throw new RimeError(RimeError.BAD_REQUEST, `${slug} is not a valid area or collection`);
+            }
+        }
+    };
+    const isCollection = (slug) => !!mapCollectionsSlug.includes(slug);
+    const isArea = (slug) => !!mapAreasSlug.includes(slug);
+    return {
+        /**
+         * Gets raw config object
+         */
+        get raw() {
+            return config;
+        },
+        /**
+         * Gets all collections config
+         */
+        get collections() {
+            return mapCollections;
+        },
+        /**
+         * Gets all areas config
+         */
+        get areas() {
+            return mapAreas;
+        },
+        /**
+         * Gets every built prototype config, whatever its kind
+         */
+        get prototypes() {
+            return allPrototypes;
+        },
+        /**
+         * Gets the default locale from the configuration
+         */
+        getDefaultLocale() {
+            return config.localization?.default || undefined;
+        },
+        /**
+         * Gets all configured locale codes
+         */
+        getLocalesCodes,
+        /**
+         * Checks if a locale code is valid according to the configuration
+         */
+        isValidLocale,
+        /**
+         * Retrieves an area configuration by its slug
+         */
+        getArea,
+        /**
+         * Retrieves a collection configuration by its slug
+         */
+        getCollection,
+        /**
+         * Retrieves either an area or collection configuration by its slug
+         */
+        getBySlug,
+        /**
+         * Checks if a slug represents a collection
+         */
+        isCollection,
+        /**
+         * Checks if a slug represents an area
+         */
+        isArea,
+        /**
+         * Determines the prototype (collection or area) of a document by its slug
+         */
+        getDocumentPrototype(slug) {
+            if (isCollection(slug))
+                return 'collection';
+            if (isArea(slug))
+                return 'area';
+            throw new RimeError(RimeError.BAD_REQUEST, slug + ' is neither a collection nor an area');
+        }
+    };
+}

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

@@ -0,0 +1,4 @@
+import * as Area from '../prototype/area/index.js';
+import * as Collection from '../prototype/collection/index.js';
+import { buildConfigClient } from './build.js';
+export { Area, Collection, buildConfigClient as rimeClient };

package/dist/core/config/index.js

@@ -0,0 +1,4 @@
+import * as Area from '../prototype/area/index.js';
+import * as Collection from '../prototype/collection/index.js';
+import { buildConfigClient } from './build.js';
+export { Area, Collection, buildConfigClient as rimeClient };

package/dist/core/config/index.server.d.ts

@@ -0,0 +1,9 @@
+import * as Area from '../prototype/area/index.js';
+import * as Collection from '../prototype/collection/index.js';
+import { Hooks } from '../pipeline/define-hook.js';
+import type { BuiltConfigClient, SanitizedConfigClient } from './types.js';
+import { buildConfig } from './build.server.js';
+export type { BuildConfig } from './build.server.js';
+/** placeholder for types */
+declare const rimeClient: (config: SanitizedConfigClient) => BuiltConfigClient;
+export { Area, Collection, Hooks, buildConfig as rime, rimeClient };

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

@@ -0,0 +1,11 @@
+import * as Area from '../prototype/area/index.js';
+import * as Collection from '../prototype/collection/index.js';
+import { Hooks } from '../pipeline/define-hook.js';
+import { buildConfig } from './build.server.js';
+/** placeholder for types */
+const rimeClient = (config) => {
+    throw new Error("Don't use this function, this is a placeholder for types only");
+    // @ts-expect-error this is a placeholder function
+    return config;
+};
+export { Area, Collection, Hooks, buildConfig as rime, rimeClient };