rimecms 0.31.5 → 0.32.1

package/dist/core/pipeline/types.d.ts

@@ -0,0 +1,140 @@
+import type { BuiltArea, BuiltCollection } from '../config/types.js';
+import type { Docs, DocType, RawDoc } from '../prototype/types.js';
+import type { RegisterArea, RegisterCollection } from '../../index.js';
+import type { PrototypeSlug } from '../../types.js';
+import type { DeepPartial, Dic } from '../../util/types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+import type { ConfigMap } from './config-map/types.js';
+export type Operation = 'read' | 'create' | 'update' | 'delete';
+export type Timing = 'before' | 'after';
+/**
+ * The points a document hook can run at.
+ *
+ * The pipeline's own vocabulary: `buildPipeline` and the two prototype lists are what read it.
+ */
+export type HookTiming = 'beforeOperation' | 'beforeRead' | 'beforeCreate' | 'afterCreate' | 'beforeUpdate' | 'afterUpdate' | 'beforeDelete' | 'afterDelete';
+/**
+ * A hook as a written list holds it.
+ *
+ * Each timing has its own argument shape (see `hooks.ts`), which a list covering every timing
+ * cannot express. Sound for the reason the erasure elsewhere is: a hook only ever reaches the
+ * timing it is placed under.
+ */
+export type AnyHook = (args: any) => any;
+export type DocTypeForSlugs<S extends DocType = PrototypeSlug> = S extends PrototypeSlug ? S extends keyof RegisterCollection ? RegisterCollection[S] : S extends keyof RegisterArea ? RegisterArea[S] : RawDoc : S extends keyof Docs ? Docs[S] : RawDoc;
+export type ConfigForSlug<S extends DocType = PrototypeSlug> = S extends keyof RegisterCollection ? BuiltCollection & {
+    slug: S;
+} : S extends keyof RegisterArea ? BuiltArea & {
+    slug: S;
+} : S extends 'auth' | 'upload' | 'directory' ? BuiltCollection : BuiltArea | BuiltCollection;
+export type HookContext<S extends DocType = PrototypeSlug, O extends Operation = Operation, T extends Timing = Timing> = {
+    event: RequestEvent;
+    context: OperationContext<S>;
+    config: ConfigForSlug<S>;
+    operation: O;
+} & (T extends 'before' ? O extends 'create' ? {
+    data: DeepPartial<DocTypeForSlugs<S>>;
+    doc?: never;
+} : O extends 'read' ? {
+    doc: DocTypeForSlugs<S>;
+    data?: never;
+} : O extends 'update' ? {
+    data: DeepPartial<DocTypeForSlugs<S>>;
+    doc?: never;
+} : O extends 'delete' ? {
+    doc: DocTypeForSlugs<S>;
+    data?: never;
+} : object : T extends 'after' ? O extends 'create' ? {
+    data: DeepPartial<DocTypeForSlugs<S>>;
+    doc: DocTypeForSlugs<S>;
+} : O extends 'read' ? {
+    doc: DocTypeForSlugs<S>;
+    data?: never;
+} : O extends 'update' ? {
+    data: DeepPartial<DocTypeForSlugs<S>>;
+    doc: DocTypeForSlugs<S>;
+} : O extends 'delete' ? {
+    doc: DocTypeForSlugs<S>;
+    data?: never;
+} : object : object);
+export type Hook<S extends DocType = PrototypeSlug, O extends Operation = Operation, T extends Timing = Timing> = (context: HookContext<S, O, T>) => Promise<HookContext<S, O, T>>;
+type HookBeforeOperationArgs<S extends DocType = PrototypeSlug, O extends Operation = Operation> = {
+    event: RequestEvent;
+    context: OperationContext<S>;
+    config: S extends PrototypeSlug ? ConfigForSlug<S> : BuiltCollection | BuiltArea;
+    operation: O;
+};
+export type HookBeforeOperation<S extends DocType = PrototypeSlug, O extends Operation = Operation> = (args: HookBeforeOperationArgs<S, O>) => Promise<HookBeforeOperationArgs<S, O>>;
+export type OperationContext<S extends DocType = 'raw'> = Dic & {
+    /** Parameters passed to the original operation method */
+    params: {
+        id?: string;
+        versionId?: string;
+        sort?: string;
+        locale?: string;
+        offset?: number;
+        limit?: number;
+        depth?: number;
+        select?: string[];
+        query?: OperationQuery;
+        /** The newest version rather than the published one — `PARAMS.LATEST`. */
+        latest?: boolean;
+        /** Make a new version from the selected row rather than write it — `PARAMS.FORK`. */
+        fork?: boolean;
+        /** The panel typing over a document. Set by the panel form actions only, never by REST. */
+        autoSave?: boolean;
+    };
+    /**
+     * The row this document's content lives on, which is what its blocks, tree nodes and relations
+     * hang off.
+     *
+     * The base row for a plain document, and the version row for one that is versioned — `versions`
+     * is the feature that makes those differ, and it is what sets this (see
+     * features/versions/hooks/handle-new-version.server.ts). `params.versionId` above stays what the
+     * caller asked for; this is where the answer goes.
+     */
+    contentOwnerId?: string;
+    /**
+     * The write copies one locale's rows onto another row — `copyLocales`. What it writes was
+     * validated and hooked where it came from, so validation, field hooks and field access stand
+     * down: a required field a locale never filled stays empty on the copy too.
+     */
+    isLocaleCopy?: boolean;
+    /** The original document if on an update operation */
+    originalDoc?: DocTypeForSlugs<S>;
+    /** An map to get a field config by path on the original doc */
+    originalConfigMap?: ConfigMap;
+    /** An map to get a field config by path on incoming data */
+    configMap?: ConfigMap;
+    /**
+     * True when rime is the caller rather than a request's user — `rime.collection('x').system()`
+     * and `rime.area('x').system()` set it on every operation they run.
+     *
+     * What stands down for it: `authorize` (no access check), the API read cache (`cached` reads
+     * through), `stampCreatedBy`/`stampUpdatedBy` (rime is not a person, so no author is recorded),
+     * the per-field write-access check in `validateFields`, and `deletePanelLockMetas` (the lock
+     * fields stay on the document). Validation itself still runs.
+     *
+     * Who sets it: the edit-lock endpoints reading the document they are about to mark, the
+     * locale-fallback pass a create runs for the other locales, and any feature doing bookkeeping
+     * the requesting user holds no permission for. It travels on one operation's context only —
+     * a call that operation makes through the plain accessor starts without it.
+     */
+    isSystemOperation?: boolean;
+};
+/** A REST-style query string, or its parsed form. Lives here because an operation's params
+ *  carry it; the adapter consumes it from there. */
+export type OperationQuery = string | ParsedOperationQuery;
+export type ParsedOperationQuery = {
+    where: Dic;
+};
+export {};
+/**
+ * A hook's name lives on the function at runtime and deliberately **not** in its type.
+ *
+ * Putting the name in the type breaks every consumer: intersecting a
+ * function type with an object loses the assignability that lets a `Hook<'raw', 'read', 'before'>`
+ * — what `Hooks.beforeRead(fn)` infers when the handler carries no explicit slug — land in a
+ * `CollectionHooks<'pages'>`. Nothing needs it there: only the pipeline chart reads it, through
+ * `hookName()`.
+ */

package/dist/core/pipeline/types.js

@@ -0,0 +1,10 @@
+export {};
+/**
+ * A hook's name lives on the function at runtime and deliberately **not** in its type.
+ *
+ * Putting the name in the type breaks every consumer: intersecting a
+ * function type with an object loses the assignability that lets a `Hook<'raw', 'read', 'before'>`
+ * — what `Hooks.beforeRead(fn)` infers when the handler carries no explicit slug — land in a
+ * `CollectionHooks<'pages'>`. Nothing needs it there: only the pipeline chart reads it, through
+ * `hookName()`.
+ */

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

@@ -0,0 +1,84 @@
+import { dev } from '$app/environment';
+import { ERROR_CONTEXT, handleError } from '../../errors/handler.server.js';
+import { RimeError, RimeFormError } from '../../errors/index.js';
+import { extractData } from '../../pipeline/extract-data.server.js';
+import { hasAuthUser } from '../../auth/better-auth-tables.server.js';
+import { trycatch, trycatchSync } from '../../../util/function.js';
+import { email as validateEmail, password as validatePassword } from '../../fields/validate.js';
+import { json } from '@sveltejs/kit';
+import { definePlugin } from '../index.js';
+export const apiInit = definePlugin(() => {
+    const requestHandler = async (event) => {
+        if (!dev)
+            throw new RimeError(RimeError.NOT_FOUND);
+        const alreadyHasAuthUser = await hasAuthUser(event.locals.rime.adapter);
+        if (alreadyHasAuthUser || (!alreadyHasAuthUser && !dev)) {
+            throw handleError(new RimeError(RimeError.NOT_FOUND), { context: ERROR_CONTEXT.API });
+        }
+        const [extractError, data] = await trycatch(() => extractData(event.request));
+        if (extractError) {
+            throw handleError(new RimeError(RimeError.INVALID_DATA, extractError.message), {
+                context: ERROR_CONTEXT.API
+            });
+        }
+        const [error] = trycatchSync(() => validateForm(data));
+        if (error) {
+            throw handleError(new RimeError(RimeError.INVALID_DATA, error.message), {
+                context: ERROR_CONTEXT.ACTION,
+                formData: { email: data.email }
+            });
+        }
+        event.locals.isInit = true;
+        const [signUpError, response] = await trycatch(() => event.locals.rime.auth.api.signUpEmail({
+            body: {
+                email: data.email,
+                name: data.name,
+                password: data.password,
+                type: 'staff'
+            }
+        }));
+        if (signUpError) {
+            throw handleError(signUpError, {
+                context: 'api',
+                formData: { email: data.email }
+            });
+        }
+        return json({ initialized: true, user: response.user });
+    };
+    return {
+        name: 'apiInit',
+        routes: {
+            '/api/init': {
+                POST: requestHandler
+            }
+        }
+    };
+});
+const validateForm = (data) => {
+    const errors = {};
+    const { name, email, password } = data;
+    if (!email) {
+        errors.email = RimeFormError.REQUIRED_FIELD;
+    }
+    if (!name) {
+        errors.name = RimeFormError.REQUIRED_FIELD;
+    }
+    if (!password) {
+        errors.password = RimeFormError.REQUIRED_FIELD;
+    }
+    const emailValidation = validateEmail(email);
+    if (typeof emailValidation === 'string') {
+        errors.email = RimeFormError.INVALID_FIELD;
+    }
+    if (typeof name !== 'string') {
+        errors.name = RimeFormError.INVALID_FIELD;
+    }
+    const passwordValidation = validatePassword(password);
+    if (typeof passwordValidation === 'string') {
+        errors.name = RimeFormError.INVALID_FIELD;
+    }
+    if (Object.keys(errors).length > 0) {
+        throw new RimeFormError(errors);
+    }
+    return true;
+};

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

@@ -1,6 +1,6 @@
 import { getRequestEvent } from '$app/server';
 import { RimeError } from '../../errors/index.js';
-import { logger } from '../../logger/index.server.js';
+import { logger } from '../../logger.server.js';
 import fs from 'fs';
 import path from 'path';
 const cachePath = path.resolve(process.cwd(), '.cache');

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

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

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

@@ -1 +1,3 @@
-export { cache } from "$rime/modules/rimecms/core/plugins/cache";
+// Isomorphic entry — the only file anything imports. Resolves to module.ts (client build)
+// or module.server.ts (server build) via `$rime/modules:`.
+export { cache } from 'rimecms/core/plugins/cache/module';

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

@@ -0,0 +1,5 @@
+import type { RequestEvent } from '@sveltejs/kit';
+/** What an author writes under `cache`. */
+export type CacheConfig = {
+    isEnabled?: (event: RequestEvent) => boolean;
+};

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

@@ -0,0 +1,12 @@
+import type { PluginHost } from './defaults/types.js';
+import type { Plugin } from './index.js';
+/**
+ * The plugin step, once, for both sides.
+ *
+ * Each build gets its own core plugins from `plugins/defaults/`, a `$rime/modules` pair, so one
+ * function serves both. Last in the config chain, after the features have derived what they
+ * derive, so a plugin's `configure` sees the config the rest of rime will see.
+ */
+export declare const configurePlugins: <const T extends PluginHost>(config: T) => T & {
+    readonly plugins: Plugin[];
+};

package/dist/core/plugins/configure.js

@@ -0,0 +1,26 @@
+import { defaultPlugins } from './defaults/index.js';
+/**
+ * The plugin step, once, for both sides.
+ *
+ * Each build gets its own core plugins from `plugins/defaults/`, a `$rime/modules` pair, so one
+ * function serves both. Last in the config chain, after the features have derived what they
+ * derive, so a plugin's `configure` sees the config the rest of rime will see.
+ */
+export const configurePlugins = (config) => {
+    const plugins = [...defaultPlugins(config), ...(config.plugins || [])];
+    let output = config;
+    for (const plugin of plugins) {
+        if (typeof plugin.configure === 'function') {
+            output = plugin.configure(output);
+        }
+        // Register routes. Client-side this is a no-op — no client half declares any — but the
+        // branch is the plugin contract, not a server detail, so it lives with the loop.
+        if (typeof plugin.routes === 'object') {
+            output = {
+                ...output,
+                $routes: { ...(output.$routes || {}), ...plugin.routes }
+            };
+        }
+    }
+    return { ...output, plugins };
+};

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

@@ -0,0 +1 @@
+export { defaultPlugins } from 'rimecms/core/plugins/defaults/module';

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

@@ -0,0 +1,3 @@
+// Isomorphic entry — the only file anything imports. Resolves to module.ts (client build) or
+// module.server.ts (server build) via `$rime/modules:`.
+export { defaultPlugins } from 'rimecms/core/plugins/defaults/module';

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

@@ -0,0 +1,12 @@
+import type { Plugin } from '../index.js';
+import type { PluginHost } from './types.js';
+/**
+ * The plugins rime adds to every config, client half.
+ *
+ * `cache` is the only one with a client side — it contributes the panel's clear-cache button — so
+ * it is the only one here. `sse`, `apiInit` and `mailer` are server-only, and a client build
+ * importing them resolves to `undefined` rather than to nothing (see
+ * `core/dev/codegen/runtime/index.server.ts`), which is why this is a pair rather than one isomorphic
+ * array with a `dev`/`$smtp` filter.
+ */
+export declare const defaultPlugins: (config: PluginHost) => Plugin[];

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

@@ -0,0 +1,14 @@
+import { cache } from '../cache/index.js';
+/**
+ * The plugins rime adds to every config, client half.
+ *
+ * `cache` is the only one with a client side — it contributes the panel's clear-cache button — so
+ * it is the only one here. `sse`, `apiInit` and `mailer` are server-only, and a client build
+ * importing them resolves to `undefined` rather than to nothing (see
+ * `core/dev/codegen/runtime/index.server.ts`), which is why this is a pair rather than one isomorphic
+ * array with a `dev`/`$smtp` filter.
+ */
+// The config is what the server half branches on ($cache, $smtp); this side has nothing to read
+// off it, and takes it anyway so both halves are the same function.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const defaultPlugins = (config) => [cache()];

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

@@ -0,0 +1,4 @@
+import type { Plugin } from '../index.js';
+import type { PluginHost } from './types.js';
+/** The plugins rime adds to every config, server half. Two of the four are conditional. */
+export declare const defaultPlugins: (config: PluginHost) => Plugin[];

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

@@ -0,0 +1,15 @@
+import { dev } from '$app/environment';
+import { apiInit } from '../api-init/index.server.js';
+import { cache } from '../cache/index.js';
+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(),
+    // Cache plugin, with default isEnabled: event => !event.locals.user
+    cache(config.$cache || {}),
+    // Init endpoint, dev only
+    ...(dev ? [apiInit()] : []),
+    ...(config.$smtp ? [mailer(config.$smtp)] : [])
+];

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

@@ -0,0 +1,18 @@
+import type { RouteConfig } from '../../config/types.js';
+import type { CacheConfig } from '../cache/types.js';
+import type { SMTPConfig } from '../mailer/index.server.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.
+ */
+export type PluginHost = {
+    plugins?: Plugin[];
+    $routes?: Record<string, RouteConfig>;
+    $cache?: CacheConfig;
+    $smtp?: SMTPConfig;
+};

package/dist/core/plugins/defaults/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+import { RimeError } from '../../errors/index.js';
+import nodemailer from 'nodemailer';
+import { definePlugin } from '../index.js';
+export const mailer = definePlugin((smtpConfig) => {
+    const { password, ...restAuth } = smtpConfig.auth;
+    const options = {
+        secure: true,
+        ...smtpConfig,
+        auth: {
+            ...restAuth,
+            pass: password
+        }
+    };
+    const mailer = nodemailer.createTransport(options);
+    const sendMail = async (args) => {
+        try {
+            return await mailer.sendMail({ from: smtpConfig.from, ...args });
+        }
+        catch {
+            throw new RimeError(RimeError.MAIL_ERROR, 'Error while sending mail');
+        }
+    };
+    return {
+        name: 'mailer',
+        actions: {
+            sendMail
+        }
+    };
+});

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

@@ -0,0 +1,10 @@
+import {} from '@sveltejs/kit';
+export function createPluginsHandler(rime) {
+    const pluginHandlers = [];
+    for (const plugin of rime.config.raw.plugins || []) {
+        if (plugin.handler) {
+            pluginHandlers.push(plugin.handler);
+        }
+    }
+    return pluginHandlers;
+}

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

@@ -0,0 +1,16 @@
+import { type RequestHandler } from '@sveltejs/kit';
+import type { SSEAccess } from './types.js';
+/**
+ * Sends one event to every client listening on `key`.
+ *
+ * @example
+ * rime.sse.emit(`rime:pages:42`, 'rime:lock');
+ */
+export declare const emit: (key: string, event: string, payload?: Record<string, any>) => void;
+/**
+ * `GET /api/sse?keys=a,b` — the connection every event is written down.
+ *
+ * Refuses the whole connection if `access` turns down any key it names: a caller who may hear
+ * about one thing and not another opens two connections and finds out which.
+ */
+export declare const connect: (access: SSEAccess) => RequestHandler;

package/dist/core/plugins/sse/bus.server.js

@@ -0,0 +1,69 @@
+import { error } from '@sveltejs/kit';
+const clients = new Set();
+/** Long enough to be cheap, short enough to beat the usual proxy idle timeout. */
+const KEEP_ALIVE_MS = 30_000;
+/**
+ * Sends one event to every client listening on `key`.
+ *
+ * @example
+ * rime.sse.emit(`rime:pages:42`, 'rime:lock');
+ */
+export const emit = (key, event, payload = {}) => {
+    // The name travels in the data, not in an `event:` field. A named frame only reaches a client
+    // that asked for that name, which would mean every listener knowing the names up front.
+    const frame = `data: ${JSON.stringify({ event, payload })}\n\n`;
+    for (const client of clients) {
+        if (!client.keys.has(key))
+            continue;
+        void client.writer.write(frame).catch(() => clients.delete(client));
+    }
+};
+/**
+ * `GET /api/sse?keys=a,b` — the connection every event is written down.
+ *
+ * Refuses the whole connection if `access` turns down any key it names: a caller who may hear
+ * about one thing and not another opens two connections and finds out which.
+ */
+export const connect = (access) => {
+    /**
+     * `rime:` is the panel's own and always needs staff — not negotiable, so `access` never sees
+     * those keys. Every other key is the app's to open.
+     */
+    const allowed = (key, user) => key.startsWith('rime:') ? !!user?.isStaff : access(key, user);
+    return ({ request, url, locals }) => {
+        const keys = new Set((url.searchParams.get('keys') ?? '').split(',').filter(Boolean));
+        if (!keys.size)
+            error(400, 'no keys');
+        for (const key of keys) {
+            // 403, not 404: the caller has a session, it just does not reach this key.
+            if (!allowed(key, locals.user))
+                error(403);
+        }
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        const client = { writer, keys };
+        clients.add(client);
+        // A comment frame, so the client's `onopen` fires before the first real event.
+        // Every write and the close are caught: a client that goes away mid-write rejects, and an
+        // uncaught one takes the process down rather than just dropping that client.
+        void writer.write(`: open ${new Date().toISOString()}\n\n`).catch(leave);
+        const keepAlive = setInterval(() => {
+            void writer.write(`: keep-alive\n\n`).catch(leave);
+        }, KEEP_ALIVE_MS);
+        function leave() {
+            clearInterval(keepAlive);
+            clients.delete(client);
+        }
+        request.signal.addEventListener('abort', () => {
+            leave();
+            void writer.close().catch(() => { });
+        });
+        return new Response(readable, {
+            headers: {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive'
+            }
+        });
+    };
+};

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

@@ -1,19 +1,17 @@
-import type { ContentUpdatePayload } from './types.js';
-export type SSEEvent = {
-    type: string;
-    details: ContentUpdatePayload;
-};
-type SSEHandler = (event: SSEEvent) => void | Promise<void>;
+import type { SSEHandler } from './types.js';
 /**
- * Opens an SSE connection with a single event handler.
+ * Listen to the key, or keys, you name. Returns the unsubscribe.
+ *
+ * The keys go in the request, so the server decides once whether you may hear them and then
+ * sends you only those — nothing arrives that you did not ask for.
+ *
+ * Callers naming the same keys share one connection: a browser allows only a handful per origin,
+ * and the panel has a listener per open document. It opens on the first caller and closes when
+ * the last one leaves.
+ *
  * @example
- * const close = openSse(async (evt) => {
- *   if (evt.type === 'rime:update') {
- *     if (evt.details.documentType === 'pages') {
- *       await invalidateAll();
- *     }
- *   }
- * });
+ * $effect(() => openSse(`rime:pages:${id}`, ({ event }) => {
+ *   if (event === 'rime:lock') invalidateAll();
+ * }));
  */
-export declare const openSse: (handler: SSEHandler) => (() => void);
-export {};
+export declare const openSse: (keys: string | string[], handler: SSEHandler) => (() => void);

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

@@ -1,43 +1,51 @@
 /**
- * Opens an SSE connection with a single event handler.
+ * Listen to the key, or keys, you name. Returns the unsubscribe.
+ *
+ * The keys go in the request, so the server decides once whether you may hear them and then
+ * sends you only those — nothing arrives that you did not ask for.
+ *
+ * Callers naming the same keys share one connection: a browser allows only a handful per origin,
+ * and the panel has a listener per open document. It opens on the first caller and closes when
+ * the last one leaves.
+ *
  * @example
- * const close = openSse(async (evt) => {
- *   if (evt.type === 'rime:update') {
- *     if (evt.details.documentType === 'pages') {
- *       await invalidateAll();
- *     }
- *   }
- * });
+ * $effect(() => openSse(`rime:pages:${id}`, ({ event }) => {
+ *   if (event === 'rime:lock') invalidateAll();
+ * }));
  */
-export const openSse = (handler) => {
-    const es = new EventSource('/api/sse');
-    console.log('[SSE] init client');
-    // Handle custom events (rime:*)
-    const handleCustomEvent = async (evt) => {
-        console.log('[SSE Client] get custom event', evt.type, evt.data);
+export const openSse = (keys, handler) => {
+    const connection = connect(keys);
+    connection.handlers.add(handler);
+    return () => {
+        connection.handlers.delete(handler);
+        if (connection.handlers.size === 0) {
+            connection.source.close();
+            shared.delete(connection.keys);
+        }
+    };
+};
+/** One entry per distinct set of keys — a different set is a different URL, so a new stream. */
+const shared = new Map();
+const connect = (keys) => {
+    // Sorted, so two callers naming the same keys in a different order share one stream.
+    const id = [...new Set(typeof keys === 'string' ? [keys] : keys)].sort().join(',');
+    const existing = shared.get(id);
+    if (existing)
+        return existing;
+    const source = new EventSource(`/api/sse?keys=${encodeURIComponent(id)}`);
+    const connection = { source, handlers: new Set(), keys: id };
+    source.onerror = (error) => console.error('[sse] connection error', error);
+    source.onmessage = (message) => {
+        let event;
         try {
-            const details = JSON.parse(evt.data);
-            await handler({
-                type: evt.type,
-                details
-            });
+            event = JSON.parse(message.data);
         }
         catch (error) {
-            console.error('[SSE Client] Failed to parse event:', error, evt.data);
+            return console.error('[sse] unreadable event', error, message.data);
         }
+        for (const handler of connection.handlers)
+            void handler(event);
     };
-    // Listen for all rime events
-    const eventTypes = ['rime:create', 'rime:update', 'rime:delete'];
-    eventTypes.forEach((eventType) => {
-        es.addEventListener(eventType, handleCustomEvent);
-    });
-    es.onopen = () => console.log('[SSE Client] Connection opened');
-    es.onerror = (e) => console.error('[SSE Client] Connection error:', e);
-    return () => {
-        console.log('[SSE Client] Closing connection');
-        eventTypes.forEach((eventType) => {
-            es.removeEventListener(eventType, handleCustomEvent);
-        });
-        es.close();
-    };
+    shared.set(id, connection);
+    return connection;
 };

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

@@ -1,2 +1,10 @@
-/// <reference path="../../../.rime-modules.d.ts" />
-export { sse } from "$rime/modules/rimecms/core/plugins/sse";
+/**
+ * The event stream, client half. The server half is `index.server.ts`.
+ *
+ * - The client calls `openSse` with the keys it wants, which opens `GET /api/sse?keys=…`.
+ * - The server answers it in `connect`: it checks each key, then leaves the response open.
+ * - The server sends an event with `emit`, which writes it to the connections holding that key.
+ * - The client's handler is called with that event.
+ */
+export { openSse } from './client.js';
+export type { SSEAccess, SSEEvent, SSEHandler } from './types.js';