rimecms 0.32.1 → 1.0.0

package/dist/core/logger.server.js

@@ -43,8 +43,14 @@ const formatMessage = (args) => {
 /**
  * Clean up old log files that exceed the maximum retention period
  */
+// The cleanup lists the log directory; once an hour is plenty, once a line was every request.
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+let lastCleanup = 0;
+
 const cleanupOldLogs = async () => {
   if (!LOG_TO_FILE) return;
+  if (Date.now() - lastCleanup < CLEANUP_INTERVAL_MS) return;
+  lastCleanup = Date.now();
 
   try {
     // Create logs directory if it doesn't exist
@@ -129,13 +135,16 @@ const isLevelEnabled = (level) => {
   return level >= currentLogLevel;
 };
 
+// One formatter, built once: `toLocaleTimeString` with options builds one per call.
+const localTime = new Intl.DateTimeFormat(undefined, {
+  hour: 'numeric',
+  minute: '2-digit',
+  second: '2-digit',
+  hour12: true
+});
+
 function getFormattedLocalTime(date) {
-  return date.toLocaleTimeString(undefined, {
-    hour: 'numeric',
-    minute: '2-digit',
-    second: '2-digit',
-    hour12: true
-  });
+  return localTime.format(date);
 }
 
 const rimeFormatted = chalk.bold(chalk.gray('[rime]'));

package/dist/core/pipeline/build-document.server.d.ts

@@ -2,6 +2,7 @@ import type { DocumentRows } from '../adapter.js';
 import type { BuiltArea, BuiltCollection } from '../config/types.js';
 import type { GenericDoc } from '../prototype/types.js';
 import type { RequestEvent } from '@sveltejs/kit';
+import { type Populated } from './populate-relations.server.js';
 /**
  * Assembles one document out of the rows it is stored across.
  *
@@ -15,6 +16,8 @@ export declare const buildDocument: <T extends GenericDoc = GenericDoc>(rows: Do
     event: RequestEvent;
     locale?: string | undefined;
     depth?: number;
+    /** What the relations point at, read ahead for the whole list. Read when `depth > 0`. */
+    populated?: Populated;
     /** Merge the blank document, so every field the config declares is present. */
     withBlank?: boolean;
     /**

package/dist/core/pipeline/build-document.server.js

@@ -1,7 +1,7 @@
-import { isObjectLiteral, omit } from '../../util/object.js';
-import deepmerge from 'deepmerge';
+import { isObjectLiteral, omit, withDefaults } from '../../util/object.js';
 import { unflatten } from 'flat';
 import { logger } from '../logger.server.js';
+import { populatedKey } from './populate-relations.server.js';
 /**
  * Assembles one document out of the rows it is stored across.
  *
@@ -11,7 +11,7 @@ import { logger } from '../logger.server.js';
  * happens to them from here is a question about documents.
  */
 export const buildDocument = async (rows, args) => {
-    const { config, event, locale, depth = 0, withBlank = true, withRowMeta = false } = args;
+    const { config, event, locale, depth = 0, populated, withBlank = true, withRowMeta = false } = args;
     const { rime } = event.locals;
     const flatDoc = { ...rows.base };
     for (const block of rows.blocks) {
@@ -40,9 +40,12 @@ export const buildDocument = async (rows, args) => {
         }
         let output;
         if (depth > 0) {
-            output = await rime
-                .collection(relation.relationTo)
-                .findById({ id: relation.documentId, locale: relation.locale, depth: depth - 1 });
+            const target = populated?.get(populatedKey(relation.relationTo, relation.locale, relation.documentId));
+            // Missing, or not readable by this reader: the relation is left out.
+            if (!target)
+                continue;
+            // A copy per placement: two documents never share an object a hook could change.
+            output = structuredClone(target);
         }
         else {
             output = (withRowMeta ? relation : omit(['position', 'ownerId', 'path'], relation));
@@ -54,7 +57,7 @@ export const buildDocument = async (rows, args) => {
         const blank = rime.config.isCollection(config.slug)
             ? rime.collection(config.slug).blank()
             : rime.area(config.slug).blank();
-        doc = deepmerge(blank, doc, { arrayMerge: (_, incoming) => incoming });
+        doc = withDefaults(doc, blank);
     }
     return doc;
 };

package/dist/core/pipeline/config-map/index.d.ts

@@ -3,4 +3,13 @@ import type { GenericDoc } from '../../prototype/types.js';
 import type { Field } from '../../../fields/types.js';
 import type { DeepPartial } from '../../../util/types.js';
 import type { ConfigMap } from './types.js';
+/**
+ * Every field a document carries, keyed by the path its value sits at.
+ *
+ * The keys are the on-disk path format, so the block type the walk names is stripped:
+ *
+ * ```
+ * layout.0:hero.title -> layout.0.title
+ * ```
+ */
 export declare const buildConfigMap: (data: DeepPartial<GenericDoc>, incomingFields: FieldBuilder<Field>[]) => ConfigMap;

package/dist/core/pipeline/config-map/index.js

@@ -1,54 +1,20 @@
 import { isFormField } from '../../fields/util.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 { buildTreeFieldsMap } from './build-tree-map.js';
+import { walkValues } from '../../fields/walk.js';
+import { normalizeFieldPath } from '../../../util/string.js';
+/**
+ * Every field a document carries, keyed by the path its value sits at.
+ *
+ * The keys are the on-disk path format, so the block type the walk names is stripped:
+ *
+ * ```
+ * layout.0:hero.title -> layout.0.title
+ * ```
+ */
 export const buildConfigMap = (data, incomingFields) => {
-    let map = {};
-    const traverseData = (data, fields, basePath) => {
-        if (!data)
-            return;
-        basePath = basePath === '' ? basePath : `${basePath}.`;
-        for (const field of fields) {
-            if (field instanceof TabsBuilder) {
-                for (const tab of field.get.tabs) {
-                    if (tab.name in data) {
-                        traverseData(data[tab.name], tab.get.fields, tab.name);
-                    }
-                }
-                continue;
-            }
-            if (!isFormField(field))
-                continue;
-            if (!(field.name in data))
-                continue;
-            const value = data[field.name];
-            const path = `${basePath}${field.name}`;
-            map[path] = field;
-            if (field instanceof BlocksBuilder && value && Array.isArray(value)) {
-                const blocks = value;
-                for (const [index, block] of blocks.entries()) {
-                    try {
-                        const blockConfig = field.get.blocks.find((b) => b.name === block.type);
-                        if (blockConfig) {
-                            traverseData(block, blockConfig.get.fields, `${path}.${index}`);
-                        }
-                    }
-                    catch {
-                        console.warn(`block at path ${path} and postition ${index} not found but there are some residual data owned by this block`);
-                    }
-                }
-            }
-            else if (field instanceof TreeBuilder && value && Array.isArray(value)) {
-                const treeMap = buildTreeFieldsMap(field, value, path);
-                map = { ...map, ...treeMap };
-            }
-            else if (field instanceof GroupFieldBuilder) {
-                traverseData(value, field.get.fields, path);
-            }
-        }
-    };
-    traverseData(data, incomingFields, '');
+    const map = {};
+    for (const { field, path } of walkValues(incomingFields, data)) {
+        if (isFormField(field))
+            map[normalizeFieldPath(path)] = field;
+    }
     return map;
 };

package/dist/core/pipeline/hooks/process-document-fields.server.d.ts

@@ -1,5 +1,8 @@
 /**
  * Walks every field of the document on the way out: drops what the reader may not see, fills an
  * empty one from its default, and hands each value to the field's own `hooks.beforeRead`.
+ *
+ * One copy of the document, walked in place. A config-map key is already normalized, so it is
+ * its segments and nothing else; a copy of the document per key was most of this hook.
  */
 export declare const processDocumentFields: import("../types.js").Hook<"raw", "read", "before">;

package/dist/core/pipeline/hooks/process-document-fields.server.js

@@ -1,31 +1,35 @@
 import { Hooks } from '../define-hook.js';
 import { logger } from '../../logger.server.js';
-import { deleteValueAtPath, getValueAtPath, setValueAtPath } from '../../../util/object.js';
 import { buildConfigMap } from '../config-map/index.js';
 import { getDefaultValue } from './set-default-values.server.js';
 /**
  * Walks every field of the document on the way out: drops what the reader may not see, fills an
  * empty one from its default, and hands each value to the field's own `hooks.beforeRead`.
+ *
+ * One copy of the document, walked in place. A config-map key is already normalized, so it is
+ * its segments and nothing else; a copy of the document per key was most of this hook.
  */
 export const processDocumentFields = Hooks.beforeRead(async function processDocumentFields(args) {
     const { event } = args;
-    let doc = args.doc;
+    const doc = { ...args.doc };
     const configMap = buildConfigMap(doc, args.config.fields);
     for (const [key, config] of Object.entries(configMap)) {
-        let value = getValueAtPath(key, doc);
-        let isEmpty;
+        const parts = key.split('.');
         if (!config.use.accessRead(event.locals.user)) {
-            doc = deleteValueAtPath(doc, key);
+            deleteAt(doc, parts);
             continue;
         }
-        if (value !== undefined && value !== null) {
+        let value = getAt(doc, parts);
+        // A field with no hook has nothing to wait for.
+        if (value !== undefined && value !== null && config.get.hooks?.beforeRead?.length) {
             value = await config.use.beforeRead(value, {
                 event,
                 operation: args.context,
                 documentId: doc.id
             });
-            doc = setValueAtPath(key, doc, value);
+            setAt(doc, parts, value);
         }
+        let isEmpty;
         try {
             isEmpty = config.use.isEmpty(value);
         }
@@ -35,10 +39,10 @@ export const processDocumentFields = Hooks.beforeRead(async function processDocu
         }
         if (isEmpty && config.get.defaultValue !== undefined) {
             value = await getDefaultValue({ key, config, adapter: args.event.locals.rime.adapter });
-            doc = setValueAtPath(key, doc, value);
+            setAt(doc, parts, value);
         }
         if (config.type === 'blocks') {
-            const value = getValueAtPath(key, doc);
+            const blocks = getAt(doc, parts);
             // Filter out possible undefined block or residual
             // Case undefined : When in dev mode, if a block table is deleted in a migration, a blocks array value could includes undefined ex :
             // * blocks: [ { ... }, undefined, { ... } ]
@@ -47,16 +51,48 @@ export const processDocumentFields = Hooks.beforeRead(async function processDocu
             // * blocks: [ { id:..., values,... }, { image: {...}} ]
             //                                         ^
             // * the image has been placed but the block doesn't exist anymore
-            if (value) {
-                const withoutResidualBlock = value
+            if (blocks) {
+                const withoutResidualBlock = blocks
                     .filter((b) => b && 'id' in b) // get only blocks that have .id
                     .map((b, index) => ({
                     ...b,
                     position: index
                 }));
-                doc = setValueAtPath(key, doc, withoutResidualBlock);
+                setAt(doc, parts, withoutResidualBlock);
             }
         }
     }
     return { ...args, doc };
 });
+/** The value the segments lead to, `undefined` past a missing one. */
+const getAt = (doc, parts) => {
+    let current = doc;
+    for (const part of parts) {
+        if (current === undefined || current === null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+};
+/** Writes at the segments, opening an object — an array before an index — where one is missing. */
+const setAt = (doc, parts, value) => {
+    let current = doc;
+    for (let index = 0; index < parts.length - 1; index++) {
+        const part = parts[index];
+        if (!current[part])
+            current[part] = /^\d+$/.test(parts[index + 1]) ? [] : {};
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+};
+/** Removes what the segments lead to; nothing, past a missing one. */
+const deleteAt = (doc, parts) => {
+    let current = doc;
+    for (const part of parts.slice(0, -1)) {
+        if (current === undefined || current === null || !(part in current))
+            return;
+        current = current[part];
+    }
+    if (current !== undefined && current !== null)
+        delete current[parts[parts.length - 1]];
+};

package/dist/core/pipeline/hooks/set-default-values.server.d.ts

@@ -12,5 +12,6 @@ type GetDefaultValue = (args: {
     config: FormFieldBuilder;
     adapter: Adapter;
 }) => Promise<any>;
+/** A relation's default is ids; they become junction rows, checked against the collection. */
 export declare const getDefaultValue: GetDefaultValue;
 export {};

package/dist/core/pipeline/hooks/set-default-values.server.js

@@ -71,6 +71,7 @@ const defaultRelationValue = async (config, key, adapter) => {
     };
     return await buildRelation(config.use.defaultValue({ event: getRequestEvent() }));
 };
+/** A relation's default is ids; they become junction rows, checked against the collection. */
 export const getDefaultValue = async ({ key, config, adapter }) => {
     if (config instanceof RelationFieldBuilder) {
         return await defaultRelationValue(config, key, adapter);

package/dist/core/pipeline/persist/blocks/extract.server.js

@@ -1,4 +1,4 @@
-import { normalizeFieldPath } from '../../../../util/path.js';
+import { normalizeFieldPath } from '../../../../util/string.js';
 import { getValueAtPath } from '../../../../util/object.js';
 export function extractBlocks({ data, configMap }) {
     const blocks = [];

package/dist/core/pipeline/persist/relations/extract.server.js

@@ -2,6 +2,8 @@ import { RelationFieldBuilder } from '../../../../fields/relation/index.js';
 import { getValueAtPath } from '../../../../util/object.js';
 export const extractRelations = ({ ownerId, data, configMap, locale }) => {
     const relations = [];
+    // The config map keys every field the document holds; relations are the ones stored as junction
+    // rows, and the key is the `path` those rows carry.
     for (const [path, config] of Object.entries(configMap)) {
         if (config instanceof RelationFieldBuilder) {
             const value = getValueAtPath(path, data);

package/dist/core/pipeline/populate-relations.server.d.ts

@@ -0,0 +1,27 @@
+import type { DocumentRows } from '../adapter.js';
+import type { GenericDoc } from '../prototype/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * The documents a list's relations point at, keyed by `populatedKey`.
+ *
+ * Read for one operation, by one reader, and dropped with it.
+ */
+export type Populated = Map<string, GenericDoc>;
+export declare const populatedKey: (slug: string, locale: string | undefined, id: string) => string;
+/**
+ * Reads what the relations of a whole list point at, one `findByIds` per collection and locale.
+ *
+ * ```ts
+ * // 20 pages, 2 relations each, 22 distinct targets
+ * // 40 × findById  ->  1 × findByIds({ ids: [...22] })
+ * ```
+ *
+ * A relation row keeps its own locale, or none: the target is read in that locale, else in the
+ * request's, as `findById` would. A target that is missing or refused to this reader is absent
+ * from the map.
+ */
+export declare const populateRelations: (rows: DocumentRows[], args: {
+    event: RequestEvent;
+    locale?: string;
+    depth: number;
+}) => Promise<Populated>;

package/dist/core/pipeline/populate-relations.server.js

@@ -0,0 +1,42 @@
+export const populatedKey = (slug, locale, id) => `${slug}:${locale ?? ''}:${id}`;
+/**
+ * Reads what the relations of a whole list point at, one `findByIds` per collection and locale.
+ *
+ * ```ts
+ * // 20 pages, 2 relations each, 22 distinct targets
+ * // 40 × findById  ->  1 × findByIds({ ids: [...22] })
+ * ```
+ *
+ * A relation row keeps its own locale, or none: the target is read in that locale, else in the
+ * request's, as `findById` would. A target that is missing or refused to this reader is absent
+ * from the map.
+ */
+export const populateRelations = async (rows, args) => {
+    const { event, locale, depth } = args;
+    const groups = new Map();
+    for (const relation of rows.flatMap((row) => row.relations)) {
+        if (!relation.documentId)
+            continue;
+        // A row written in another locale is not part of this read.
+        if (relation.locale && relation.locale !== locale)
+            continue;
+        const key = `${relation.relationTo}:${relation.locale ?? ''}`;
+        const group = groups.get(key) ?? {
+            slug: relation.relationTo,
+            locale: relation.locale ?? undefined,
+            ids: new Set()
+        };
+        group.ids.add(relation.documentId);
+        groups.set(key, group);
+    }
+    const populated = new Map();
+    await Promise.all([...groups.values()].map(async (group) => {
+        const docs = await event.locals.rime
+            .collection(group.slug)
+            .findByIds({ ids: [...group.ids], locale: group.locale, depth: depth - 1 });
+        for (const doc of docs) {
+            populated.set(populatedKey(group.slug, group.locale, doc.id), doc);
+        }
+    }));
+    return populated;
+};

package/dist/core/pipeline/run.server.d.ts

@@ -97,12 +97,7 @@ export declare const persistRelational: (args: {
     config: AnyConfig;
     locale?: string | undefined;
 }) => Promise<void>;
-/**
- * The read tail shared by findById and an area's find: turn a raw adapter row into a document,
- * then run the beforeRead chain over it.
- */
-export declare const readDocument: <S extends DocType, T extends GenericDoc>(args: {
-    raw: RawDoc;
+type ReadArgs<S extends DocType> = {
     config: AnyConfig;
     event: RequestEvent;
     context: OperationContext<S>;
@@ -110,6 +105,22 @@ export declare const readDocument: <S extends DocType, T extends GenericDoc>(arg
     localeFallback?: boolean;
     depth?: number;
     select?: string[];
+};
+/**
+ * The read tail of a list: every raw adapter row turned into rows, what their relations point at
+ * read in one pass, then each document built and run through the beforeRead chain.
+ *
+ * One settled result per raw, in order: a document that fails is the caller's to skip or throw.
+ */
+export declare const readDocuments: <S extends DocType, T extends GenericDoc>(args: ReadArgs<S> & {
+    raws: RawDoc[];
+}) => Promise<PromiseSettledResult<{
+    doc: T;
+    context: OperationContext<S>;
+}>[]>;
+/** The read tail of a single document: `readDocuments` over one raw row, its failure thrown. */
+export declare const readDocument: <S extends DocType, T extends GenericDoc>(args: ReadArgs<S> & {
+    raw: RawDoc;
 }) => Promise<{
     doc: T;
     context: OperationContext<S>;

package/dist/core/pipeline/run.server.js

@@ -1,6 +1,7 @@
 import { RimeError } from '../errors/index.js';
 import { versionsWritePlan } from '../prototype/shared/versions/write-plan.js';
 import { buildDocument } from './build-document.server.js';
+import { populateRelations } from './populate-relations.server.js';
 import { saveBlocks } from './persist/blocks/index.server.js';
 import { saveRelations } from './persist/relations/index.server.js';
 import { saveTreeBlocks } from './persist/tree/index.server.js';
@@ -133,42 +134,55 @@ export const persistRelational = async (args) => {
     });
 };
 /**
- * The read tail shared by findById and an area's find: turn a raw adapter row into a document,
- * then run the beforeRead chain over it.
+ * The read tail of a list: every raw adapter row turned into rows, what their relations point at
+ * read in one pass, then each document built and run through the beforeRead chain.
+ *
+ * One settled result per raw, in order: a document that fails is the caller's to skip or throw.
  */
-export const readDocument = async (args) => {
-    const { raw, config, event, locale, localeFallback, depth, select } = args;
+export const readDocuments = async (args) => {
+    const { raws, config, event, locale, localeFallback, depth = 0, select } = args;
     const hasSelect = !!select && Array.isArray(select) && !!select.length;
-    const rows = await event.locals.rime.adapter.transform.rows({
+    const rows = await Promise.allSettled(raws.map((raw) => event.locals.rime.adapter.transform.rows({
         doc: raw,
         slug: config.slug,
         locale,
         localeFallback
-    });
-    const document = await buildDocument(rows, {
-        config,
-        event,
-        locale,
-        depth,
-        withBlank: !hasSelect,
-        /**
-         * The panel edits blocks and tree nodes in place, so it needs each child row's own
-         * bookkeeping — `position`, `path`, `ownerId`, `locale` — kept on it.
-         *
-         * The adapter used to work this out for itself, by testing `event.params.panel`. Core naming
-         * the panel here is the last of that coupling (core letting go of `src/lib/panel/`), and it
-         * is one line rather than four `if`s in the database layer.
-         */
-        withRowMeta: event.params.panel !== undefined
-    });
-    return runDocHooks({
-        hooks: config.$hooks?.beforeRead,
-        doc: document,
-        config,
-        event,
-        operation: 'read',
-        context: args.context
-    });
+    })));
+    const populated = depth > 0
+        ? await populateRelations(rows.flatMap((row) => (row.status === 'fulfilled' ? [row.value] : [])), { event, locale, depth })
+        : undefined;
+    return Promise.allSettled(rows.map(async (row) => {
+        if (row.status === 'rejected')
+            throw row.reason;
+        const document = await buildDocument(row.value, {
+            config,
+            event,
+            locale,
+            depth,
+            populated,
+            withBlank: !hasSelect,
+            /**
+             * The panel edits blocks and tree nodes in place, so it needs each child row's own
+             * bookkeeping — `position`, `path`, `ownerId`, `locale` — kept on it.
+             */
+            withRowMeta: event.params.panel !== undefined
+        });
+        return runDocHooks({
+            hooks: config.$hooks?.beforeRead,
+            doc: document,
+            config,
+            event,
+            operation: 'read',
+            context: args.context
+        });
+    }));
+};
+/** The read tail of a single document: `readDocuments` over one raw row, its failure thrown. */
+export const readDocument = async (args) => {
+    const [result] = await readDocuments({ ...args, raws: [args.raw] });
+    if (result.status === 'rejected')
+        throw result.reason;
+    return result.value;
 };
 /**
  * The update pipeline, prototype-parameterized.

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

@@ -29,7 +29,7 @@ export declare const cache: (options?: CacheOptions) => {
     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;
+            readonly POST: (event: RequestEvent) => Response;
         };
     };
     readonly actions: CacheActions;

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

@@ -1,4 +1,5 @@
-import { json } from '@sveltejs/kit';
+import { isStaff } from '../../auth/access.js';
+import { error, json } from '@sveltejs/kit';
 import { createHash } from 'node:crypto';
 import { definePlugin } from '../index.js';
 import { Cache } from './cache.server.js';
@@ -20,9 +21,7 @@ export const cache = definePlugin((options) => {
     async function getAction(key, get) {
         return await Cache.get(key, get);
     }
-    /**
-     * Empty the .cache folder
-     */
+    /** Empties the cache. A config's hook calls it as an action; the route below guards it. */
     const clearCache = () => {
         Cache.clear();
         return json({ message: 'Cache cleared' });
@@ -59,8 +58,9 @@ export const cache = definePlugin((options) => {
             return config;
         },
         routes: {
+            // Staff only: the route is public, and an empty cache is a cost.
             '/api/clear-cache': {
-                POST: clearCache
+                POST: (event) => (isStaff(event.locals.user) ? clearCache() : error(403))
             }
         },
         actions,

package/dist/core/plugins/defaults/module.server.js

@@ -5,8 +5,8 @@ import { mailer } from '../mailer/index.server.js';
 import { sse } from '../sse/index.server.js';
 /** The plugins rime adds to every config, server half. Two of the four are conditional. */
 export const defaultPlugins = (config) => [
-    // Server Sent Events
-    sse(),
+    // The event stream, `$sse` says which keys an app opens
+    sse(config.$sse),
     // Cache plugin, with default isEnabled: event => !event.locals.user
     cache(config.$cache || {}),
     // Init endpoint, dev only

package/dist/core/plugins/defaults/types.d.ts

@@ -1,18 +1,20 @@
 import type { RouteConfig } from '../../config/types.js';
 import type { CacheConfig } from '../cache/types.js';
 import type { SMTPConfig } from '../mailer/index.server.js';
+import type { SSEConfig } from '../sse/types.js';
 import type { Plugin } from '../index.js';
 /**
  * What the plugin step reads off a config.
  *
  * Both halves of `defaultPlugins` take this rather than `Config` or `SanitizedConfigClient`: the
- * step runs on both sides, and naming either one there would pin it to a side. `$cache` and
- * `$smtp` are what the server half branches on; a client build reads neither, and still takes the
- * argument so the two halves are the same function.
+ * step runs on both sides, and naming either one there would pin it to a side. `$cache`, `$smtp`
+ * and `$sse` are what the server half reads; a client build reads none of them, and still takes
+ * the argument so the two halves are the same function.
  */
 export type PluginHost = {
     plugins?: Plugin[];
     $routes?: Record<string, RouteConfig>;
     $cache?: CacheConfig;
     $smtp?: SMTPConfig;
+    $sse?: SSEConfig;
 };

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

@@ -7,4 +7,4 @@
  * - The client's handler is called with that event.
  */
 export { openSse } from './client.js';
-export type { SSEAccess, SSEEvent, SSEHandler } from './types.js';
+export type { SSEAccess, SSEConfig, SSEEvent, SSEHandler } from './types.js';

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

@@ -1,7 +1,7 @@
 import { emit } from './bus.server.js';
-import type { SSEAccess } from './types.js';
+import type { SSEConfig } from './types.js';
 /**
- * The event stream, at `/api/sse`.
+ * The event stream, at `/api/sse`. Added to every config, configured by its `$sse` key.
  *
  * Send with `rime.sse.emit(key, event, payload)`, listen with `openSse(keys, handler)`.
  *
@@ -9,11 +9,10 @@ import type { SSEAccess } from './types.js';
  * otherwise, so an app opens its own deliberately rather than by leaving a default alone.
  *
  * @example
- * sse({ access: (key) => key.startsWith('public:') })
+ * // rime.config.server.ts
+ * $sse: { access: (key) => key.startsWith('public:') }
  */
-export declare const sse: (options?: {
-    access?: SSEAccess;
-}) => {
+export declare const sse: (options?: SSEConfig) => {
     readonly name: "sse";
     readonly actions: {
         readonly emit: (key: string, event: string, payload?: Record<string, any>) => void;