domma-cms 0.102.0 → 0.103.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.102.0",
+  "version": "0.103.0",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",

package/plugins/_lib/admin/mail/message-actions.js

@@ -0,0 +1,56 @@
+/**
+ * What other Tools add to a message's menu - Booking's "Book Sam...".
+ *
+ * Tools register actions on the `message` related kind (core 0.103,
+ * services/hooks.js); the reader asks for them once and adds them to both the
+ * full and the read-only menu. Like Contacts, an optional neighbour: an older
+ * core, no such Tool, or no permission all come back as an empty list.
+ *
+ * @module _lib/admin/mail/message-actions
+ */
+
+const PROVIDERS_ENDPOINT = '/api/related/providers?kind=message';
+
+/**
+ * The actions any Tool offers on a message, flattened.
+ *
+ * @param   {Function} api - the view's request helper
+ * @returns {Promise<{label: string, icon: string, url: string}[]>}
+ */
+export async function loadMessageActions(api) {
+    try {
+        const providers = await api(PROVIDERS_ENDPOINT);
+        if (!Array.isArray(providers)) return [];
+        return providers
+            .flatMap(p => (Array.isArray(p?.actions) ? p.actions : []))
+            .filter(a => typeof a?.label === 'string' && typeof a?.url === 'string' && a.url.startsWith('#/'));
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Who sent a message and what it is about, for the placeholders.
+ *
+ * @param   {object} message
+ * @returns {{email: string, name: string, subject: string}}
+ */
+export function messageFacts(message) {
+    const from = (message?.from ?? [])[0] ?? {};
+    const email = String(from.address ?? '').trim();
+    return {email, name: String(from.name ?? '').trim() || email, subject: String(message?.subject ?? '').trim()};
+}
+
+/**
+ * An action's label and hash for one message: `{name}` in the label, and
+ * `{email}`, `{name}`, `{subject}` (URL-encoded) in the url.
+ *
+ * @param   {{label: string, url: string}} action
+ * @param   {{email: string, name: string, subject: string}} facts
+ * @returns {{label: string, hash: string}}
+ */
+export function fillMessageAction(action, facts) {
+    const label = action.label.replace(/\{name\}/g, facts.name || 'sender');
+    const hash = action.url.replace(/\{(email|name|subject)\}/g, (_, key) => encodeURIComponent(facts[key] ?? ''));
+    return {label, hash};
+}

package/plugins/_lib/admin/mail/reader-view.js

@@ -42,6 +42,7 @@ const {openCompose: openComposeWindow} = await import(versioned('compose-window.
 const {makeResizable} = await import(versioned('resizable.js'));
 const {whenClosed} = await import(versioned('when-closed.js'));
 const {addContact, isKnownAddress, loadContacts} = await import(versioned('contacts.js'));
+const {fillMessageAction, loadMessageActions, messageFacts} = await import(versioned('message-actions.js'));
 const {isPlainKey, isTyping, resolveKey, SHORTCUTS} = await import(versioned('keyboard.js'));
 const {describeWhen, quickTimes} = await import(versioned('scheduling.js'));
 
@@ -335,6 +336,8 @@ return {
         })();
         /** Whether Contacts is installed at all - not the same as it being empty. */
         let contactsAvailable = false;
+        /** What other Tools add to a message's menu (Booking's "Book Sam..."). */
+        let messageActions = [];
         /**
          * The open message. Observable because selecting one only changes two
          * rows - the one leaving and the one arriving - and rebuilding the
@@ -2672,6 +2675,7 @@ return {
                     },
                     {type: 'divider'}
                 ] : []),
+                ...toolActionItems(message),
                 {type: 'divider'},
                 {
                     label: 'Mark as spam',
@@ -2750,10 +2754,34 @@ return {
                 ...(contactsAvailable ? [
                     {type: 'divider'},
                     {label: 'Add sender to contacts', icon: 'user-plus', disabled: () => senderKnown || !sender, action: () => addSender(message)}
-                ] : [])
+                ] : []),
+                ...(messageActions.length ? [{type: 'divider'}, ...toolActionItems(message)] : [])
             ];
         }
 
+        /**
+         * The entries other Tools add for one message, each followed by a
+         * divider in the full menu's rhythm. Greyed when there is no sender to
+         * act on, since every one of them is about the sender.
+         *
+         * @param   {object} message
+         * @returns {object[]}
+         */
+        function toolActionItems(message) {
+            if (!messageActions.length) return [];
+            const facts = messageFacts(message);
+            const items = messageActions.map(action => {
+                const {label, hash} = fillMessageAction(action, facts);
+                return {
+                    label,
+                    icon: action.icon || 'arrow-right',
+                    disabled: () => !facts.email,
+                    action: () => { location.hash = hash.replace(/^#/, ''); }
+                };
+            });
+            return features.write ? [...items, {type: 'divider'}] : items;
+        }
+
         /**
          * Put text on the clipboard, saying so - and saying so when it could not.
          *
@@ -4510,6 +4538,7 @@ return {
                 // all; the menu and the compose window both read whatever has
                 // arrived by the time they are opened.
                 refreshContacts();
+                loadMessageActions(api).then(actions => { messageActions = actions; });
 
                 mailboxes = (await api(`${BASE}/accounts`)).accounts;
             } catch (err) {

package/plugins/_lib/call/ice.js

@@ -0,0 +1,58 @@
+/**
+ * Where a call's browsers look for a route to each other (ICE servers).
+ *
+ * `config/calls.json` (optional - absent means a public STUN server only):
+ *
+ *   {
+ *     "stun": ["stun:stun.l.google.com:19302"],
+ *     "turn": {"urls": ["turn:turn.example.org:3478?transport=udp", "turn:turn.example.org:3478?transport=tcp"],
+ *              "secret": "<coturn static-auth-secret>", "ttlHours": 12}
+ *   }
+ *
+ * TURN credentials are coturn's time-limited kind (use-auth-secret): the
+ * username is "<expiry>:<label>" and the password an HMAC of it, so no
+ * account is ever stored and a copied credential stops working on its own.
+ *
+ * @module _lib/call/ice
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import {createHmac} from 'node:crypto';
+
+export const DEFAULT_STUN = ['stun:stun.l.google.com:19302'];
+
+const list = (v) => (Array.isArray(v) ? v : typeof v === 'string' ? [v] : [])
+    .map(x => String(x).trim()).filter(x => /^(stun|stuns|turn|turns):/.test(x));
+
+/** The saved call settings, cleaned. Never throws. */
+export function readCallConfig(root = process.cwd()) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(root, 'config', 'calls.json'), 'utf8'));
+        const stun = list(raw?.stun);
+        const turnUrls = list(raw?.turn?.urls);
+        const secret = typeof raw?.turn?.secret === 'string' ? raw.turn.secret : '';
+        const ttlHours = Math.max(1, Math.min(48, Number(raw?.turn?.ttlHours) || 12));
+        return {stun: stun.length ? stun : DEFAULT_STUN, turn: turnUrls.length && secret ? {urls: turnUrls, secret, ttlHours} : null};
+    } catch {
+        return {stun: DEFAULT_STUN, turn: null};
+    }
+}
+
+/**
+ * The ICE servers for one participant (the RTCPeerConnection `iceServers`).
+ *
+ * @param {{stun: string[], turn: object|null}} config
+ * @param {string} label - who the credential is for (logged by coturn), e.g. the site's host
+ * @param {number} [now]
+ */
+export function iceServers(config, label = 'call', now = Date.now()) {
+    const servers = [{urls: config.stun}];
+    if (config.turn) {
+        const expiry = Math.floor(now / 1000) + config.turn.ttlHours * 3600;
+        const username = `${expiry}:${String(label).replace(/[^\w.-]/g, '').slice(0, 60) || 'call'}`;
+        const credential = createHmac('sha1', config.turn.secret).update(username).digest('base64');
+        servers.push({urls: config.turn.urls, username, credential});
+    }
+    return servers;
+}

package/plugins/_lib/call/rooms.js

@@ -0,0 +1,232 @@
+/**
+ * Call rooms - who is in a call, who is waiting to be let in, and the
+ * messages between them. Held in memory by the site process; nothing about a
+ * call is written anywhere, so a restart simply ends the calls in progress.
+ *
+ * The browsers talk to each other directly (WebRTC). This only carries the
+ * short messages that set that up (offers, answers, candidates) plus the
+ * call's own events, over plain HTTP: a participant posts, and long-polls for
+ * what is waiting for them. Every request after joining carries the
+ * participant's id and secret.
+ *
+ * @module _lib/call/rooms
+ */
+
+import {randomBytes, timingSafeEqual} from 'node:crypto';
+
+export const MAX_PEOPLE = 6;
+const SILENT_MS = 35000;          // no poll for this long: gone
+const POLL_MS = 25000;            // a poll waits this long for something to happen
+const QUEUE_MAX = 500;            // events kept per participant (a stuck browser cannot grow it forever)
+const CHAT_MAX = 1000;
+const EMPTY_KEEP_MS = 2 * 3600e3;  // an empty room remembering who was turned away
+
+export class CallError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+
+const secretOk = (a, b) => {
+    const x = Buffer.from(String(a || ''));
+    const y = Buffer.from(String(b || ''));
+    return x.length === y.length && x.length > 0 && timingSafeEqual(x, y);
+};
+
+/**
+ * @param {{now?: () => number, pollMs?: number, silentMs?: number}} [opts]
+ */
+export function createRooms({now = Date.now, pollMs = POLL_MS, silentMs = SILENT_MS} = {}) {
+    /** key -> {key, title, max, recordingAllowed, recording, people: Map<pid, person>} */
+    const rooms = new Map();
+
+    const newId = (n) => randomBytes(n).toString('base64url');
+    const admitted = (room) => [...room.people.values()].filter(p => p.state === 'in');
+    const hosts = (room) => admitted(room).filter(p => p.host);
+    const pub = (p) => ({id: p.id, name: p.name, host: p.host});
+
+    function push(person, event) {
+        person.seq += 1;
+        person.queue.push({seq: person.seq, at: now(), ...event});
+        if (person.queue.length > QUEUE_MAX) person.queue.splice(0, person.queue.length - QUEUE_MAX);
+        const wake = person.waiters.splice(0);
+        for (const w of wake) w();
+    }
+    const tell = (people, event) => people.forEach(p => push(p, event));
+
+    function me(key, pid, secret) {
+        const room = rooms.get(key);
+        const person = room?.people.get(String(pid || ''));
+        if (!person || !secretOk(person.secret, secret)) throw new CallError('gone', 'You are not in this call. Join again.');
+        person.seen = now();
+        return {room, person};
+    }
+
+    function remove(room, person, why) {
+        if (!room.people.delete(person.id)) return;
+        for (const w of person.waiters.splice(0)) w();
+        if (person.state === 'in') tell(admitted(room), {type: 'left', id: person.id, name: person.name, why});
+        else tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
+        // The last host leaving stops a recording; nobody else can.
+        if (room.recording && !hosts(room).length) {
+            room.recording = false;
+            tell(admitted(room), {type: 'recording', on: false});
+        }
+        // An empty room goes - or, while it remembers who was turned away, two hours after it emptied (sweep).
+        if (!room.people.size) {
+            if (!room.away.size) rooms.delete(room.key);
+            else room.emptySince = now();
+        }
+    }
+
+    const waitingList = (room) => [...room.people.values()].filter(p => p.state === 'waiting').map(p => ({id: p.id, name: p.name}));
+
+    function admit(room, person) {
+        if (admitted(room).length >= room.max) throw new CallError('full', `This call is full (${room.max} people).`);
+        person.state = 'in';
+        tell(admitted(room).filter(p => p !== person), {type: 'joined', peer: pub(person)});
+        push(person, {type: 'admitted', peers: admitted(room).filter(p => p !== person).map(pub), recording: room.recording});
+        tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
+    }
+
+    return {
+        /**
+         * Join (or knock on) a room. A host is let straight in; a guest waits
+         * for a host unless the room lets everyone straight in.
+         *
+         * @param {string} key - the room, as the Tool names it ("booking:<id>")
+         * @param {{name: string, host?: boolean, title?: string, max?: number, recordingAllowed?: boolean, autoAdmit?: boolean}} who
+         */
+        join(key, {name, host = false, title = '', max = MAX_PEOPLE, recordingAllowed = false, autoAdmit = false, identity = ''}) {
+            let room = rooms.get(key);
+            if (!room) {
+                room = {key, title, max: Math.max(2, Math.min(MAX_PEOPLE, max | 0 || MAX_PEOPLE)), recordingAllowed, recording: false, people: new Map(), away: new Set()};
+                rooms.set(key, room);
+            }
+            room.emptySince = 0;
+            // Turned away once: the same link cannot knock again for as long as the call lasts.
+            if (!host && identity && room.away.has(identity)) throw new CallError('away', 'The host did not let you in to this call.');
+            // The same link joining again (a reload, a second tab) replaces its old place at once, rather than
+            // leaving a frozen copy of them in the call until the sweep notices.
+            if (identity) for (const p of [...room.people.values()]) if (p.identity === identity) remove(room, p, 'rejoined');
+            // remove() deletes a room it leaves empty - this one is about to have someone in it again.
+            rooms.set(key, room);
+            if (admitted(room).length >= room.max && (host || autoAdmit)) throw new CallError('full', `This call is full (${room.max} people).`);
+            const person = {id: newId(9), secret: newId(24), identity: String(identity || ''), name: String(name || '').trim().slice(0, 60) || (host ? 'Host' : 'Guest'),
+                host: Boolean(host), state: 'waiting', seq: 0, queue: [], waiters: [], seen: now()};
+            room.people.set(person.id, person);
+            if (host || autoAdmit) {
+                // admit() also tells every host - this one included - who is already waiting.
+                admit(room, person);
+            } else {
+                push(person, {type: 'knocking'});
+                tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
+            }
+            return {id: person.id, secret: person.secret, name: person.name, host: person.host, state: person.state, title: room.title,
+                max: room.max, recordingAllowed: room.recordingAllowed};
+        },
+
+        /** Events after `since`, waiting up to pollMs for the first one. */
+        async poll(key, pid, secret, since = 0) {
+            const {person} = me(key, pid, secret);
+            const after = () => person.queue.filter(e => e.seq > since);
+            if (!after().length) {
+                await new Promise(resolve => {
+                    const t = setTimeout(done, pollMs);
+                    // Taken off the list however it ends: a waiter left behind would make sweep() think this
+                    // person is still polling, and someone whose tab died would stay in the call for ever.
+                    function done() {
+                        clearTimeout(t);
+                        const i = person.waiters.indexOf(done);
+                        if (i >= 0) person.waiters.splice(i, 1);
+                        resolve();
+                    }
+                    person.waiters.push(done);
+                });
+            }
+            person.seen = now();
+            // Acknowledged events are dropped: the browser only ever asks for what came after.
+            person.queue = person.queue.filter(e => e.seq > since);
+            return {events: after(), state: person.state};
+        },
+
+        /** One browser's message for another (offer, answer, candidate). */
+        signal(key, pid, secret, to, data) {
+            const {room, person} = me(key, pid, secret);
+            if (person.state !== 'in') throw new CallError('waiting', 'Wait to be let in first.');
+            const other = room.people.get(String(to || ''));
+            if (!other || other.state !== 'in') return false;
+            push(other, {type: 'signal', from: person.id, data});
+            return true;
+        },
+
+        chat(key, pid, secret, text) {
+            const {room, person} = me(key, pid, secret);
+            if (person.state !== 'in') throw new CallError('waiting', 'Wait to be let in first.');
+            const clean = String(text || '').trim().slice(0, CHAT_MAX);
+            if (!clean) return false;
+            tell(admitted(room), {type: 'chat', from: person.id, name: person.name, text: clean});
+            return true;
+        },
+
+        /** A host lets someone in (yes) or turns them away (no). */
+        answer(key, pid, secret, who, yes) {
+            const {room, person} = me(key, pid, secret);
+            if (!person.host || person.state !== 'in') throw new CallError('not-host', 'Only the host can do that.');
+            const other = room.people.get(String(who || ''));
+            if (!other || other.state !== 'waiting') return false;
+            if (yes) admit(room, other);
+            else {
+                push(other, {type: 'turned-away'});
+                other.state = 'away';
+                if (other.identity) room.away.add(other.identity);
+                // They are told, then dropped when they stop polling.
+                tell(hosts(room), {type: 'waiting', waiting: waitingList(room)});
+            }
+            return true;
+        },
+
+        /** A host starts or stops recording; everyone is told. */
+        recording(key, pid, secret, on) {
+            const {room, person} = me(key, pid, secret);
+            if (!person.host || person.state !== 'in') throw new CallError('not-host', 'Only the host can record.');
+            if (!room.recordingAllowed && on) throw new CallError('no-recording', 'Recording is switched off for this call.');
+            room.recording = Boolean(on);
+            tell(admitted(room), {type: 'recording', on: room.recording, by: person.name});
+            return room.recording;
+        },
+
+        leave(key, pid, secret) {
+            const {room, person} = me(key, pid, secret);
+            remove(room, person, 'left');
+            return true;
+        },
+
+        /** Drop everyone who has stopped polling. Call every few seconds. */
+        sweep() {
+            const cut = now() - silentMs;
+            for (const room of [...rooms.values()]) {
+                for (const p of [...room.people.values()]) if (p.seen < cut && !p.waiters.length) remove(room, p, 'lost');
+                if (!room.people.size && room.emptySince && now() - room.emptySince > EMPTY_KEEP_MS) rooms.delete(room.key);
+            }
+        },
+
+        /** For the admin: how many are in a room and waiting (0 when there is no call). */
+        count(key) {
+            const room = rooms.get(key);
+            return room ? {in: admitted(room).length, waiting: waitingList(room).length} : {in: 0, waiting: 0};
+        },
+
+        /** End a call for everyone (a booking cancelled, an event deleted). */
+        close(key) {
+            const room = rooms.get(key);
+            if (!room) return;
+            tell([...room.people.values()], {type: 'ended'});
+            for (const p of room.people.values()) for (const w of p.waiters.splice(0)) w();
+            rooms.delete(key);
+        },
+
+        size: () => rooms.size
+    };
+}

package/plugins/_lib/call/routes.js

@@ -0,0 +1,88 @@
+/**
+ * The call's HTTP routes, mounted by a Tool (Booking Pro, Calendar) under its
+ * own API prefix with its OWN access rule. `_lib` on its own gives a site
+ * nothing: only a Tool that mounts this, and says who may join which room,
+ * has calls.
+ *
+ *   POST {prefix}/:room/join       {name, ...credentials}  -> {id, secret, host, state, iceServers, ...}
+ *   GET  {prefix}/:room/poll?since=N                         -> {events, state}   (long-poll, 25 s)
+ *   POST {prefix}/:room/signal     {to, data}
+ *   POST {prefix}/:room/chat       {text}
+ *   POST {prefix}/:room/answer     {who, yes}   (host: let in / turn away)
+ *   POST {prefix}/:room/recording  {on}         (host)
+ *   POST {prefix}/:room/leave
+ *
+ * After joining, every request carries `X-Call-Id` and `X-Call-Secret`
+ * (headers, so the secret never lands in an access log).
+ *
+ * @module _lib/call/routes
+ */
+
+import {CallError, createRooms} from './rooms.js';
+import {iceServers, readCallConfig} from './ice.js';
+
+const STATUS = {gone: 410, full: 409, waiting: 409, away: 403, 'not-host': 403, 'no-recording': 403};
+const BUSY = {config: {rateLimit: {max: 1200, timeWindow: '1 minute'}}};
+
+/**
+ * @param {import('fastify').FastifyInstance} fastify
+ * @param {object} opts
+ * @param {string} opts.prefix - e.g. '/call' (under the plugin's own prefix)
+ * @param {string} opts.ns - the Tool's room namespace, e.g. 'booking'
+ * @param {(request: object, room: string, body: object) => Promise<null|{title: string, host: boolean, name?: string, identity?: string,
+ *   max?: number, recordingAllowed?: boolean, autoAdmit?: boolean, opensAt?: string, closesAt?: string}>} opts.resolve
+ *   who the caller is in this room, or null when they may not join. Throw nothing: null answers 404.
+ * @param {ReturnType<typeof createRooms>} [opts.rooms] - for tests
+ * @param {() => {stun: string[], turn: object|null}} [opts.config]
+ * @returns {ReturnType<typeof createRooms>} the rooms, so the Tool can close() one or count() it
+ */
+export function mountCallRoutes(fastify, {prefix = '/call', ns, resolve, rooms = createRooms(), config = () => readCallConfig()}) {
+    if (!ns) throw new Error('mountCallRoutes needs a namespace');
+    const keyOf = (room) => `${ns}:${String(room || '').slice(0, 120)}`;
+    const who = (request) => [request.headers['x-call-id'], request.headers['x-call-secret']];
+    const fail = (reply, err) => {
+        if (err instanceof CallError) return reply.code(STATUS[err.code] || 400).send({error: err.message, code: err.code});
+        throw err;
+    };
+
+    const sweeper = setInterval(() => rooms.sweep(), 5000);
+    sweeper.unref?.();
+    fastify.addHook('onClose', async () => clearInterval(sweeper));
+
+    fastify.post(`${prefix}/:room/join`, {config: {rateLimit: {max: 30, timeWindow: '1 minute'}}}, async (request, reply) => {
+        const body = request.body || {};
+        const r = await resolve(request, String(request.params.room), body);
+        if (!r) return reply.code(404).send({error: 'This call link is not valid.'});
+        const t = Date.now();
+        if (r.opensAt && t < Date.parse(r.opensAt)) return reply.code(425).send({error: 'This call has not opened yet.', code: 'early', opensAt: r.opensAt});
+        if (r.closesAt && t > Date.parse(r.closesAt)) return reply.code(410).send({error: 'This call has ended.', code: 'closed'});
+        try {
+            const joined = rooms.join(keyOf(request.params.room), {name: r.name || body.name, host: r.host, title: r.title, max: r.max,
+                recordingAllowed: r.recordingAllowed === true, autoAdmit: r.autoAdmit === true, identity: r.identity || ''});
+            return reply.send({...joined, iceServers: iceServers(config(), request.hostname), closesAt: r.closesAt || null});
+        } catch (err) { return fail(reply, err); }
+    });
+
+    fastify.get(`${prefix}/:room/poll`, BUSY, async (request, reply) => {
+        const [id, secret] = who(request);
+        try {
+            const out = await rooms.poll(keyOf(request.params.room), id, secret, Number(request.query?.since) || 0);
+            reply.header('Cache-Control', 'no-store');
+            return reply.send(out);
+        } catch (err) { return fail(reply, err); }
+    });
+
+    const action = (name, run) => fastify.post(`${prefix}/:room/${name}`, BUSY, async (request, reply) => {
+        const [id, secret] = who(request);
+        try {
+            return reply.send({ok: true, result: run(keyOf(request.params.room), id, secret, request.body || {})});
+        } catch (err) { return fail(reply, err); }
+    });
+    action('signal', (k, id, s, b) => rooms.signal(k, id, s, b.to, b.data));
+    action('chat', (k, id, s, b) => rooms.chat(k, id, s, b.text));
+    action('answer', (k, id, s, b) => rooms.answer(k, id, s, b.who, b.yes === true));
+    action('recording', (k, id, s, b) => rooms.recording(k, id, s, b.on === true));
+    action('leave', (k, id, s) => rooms.leave(k, id, s));
+
+    return {...rooms, closeRoom: (room) => rooms.close(keyOf(room)), countRoom: (room) => rooms.count(keyOf(room))};
+}

package/plugins/_lib/public/call/call.css

@@ -0,0 +1 @@
+.dmc{--dmc-gap: .75rem;display:flex;flex-direction:column;gap:1rem;min-height:70vh;color:var(--dm-text, inherit)}.dmc [hidden]{display:none!important}.dmc-head{display:flex;align-items:center;gap:.75rem;flex-wrap:wrap}.dmc-title{font-size:1.35rem;margin:0;flex:1 1 auto}.dmc-rec{color:#fff;background:var(--dm-danger, #c62828);border-radius:999px;padding:.2rem .7rem;font-size:.85rem;font-weight:600}.dmc-count{color:var(--dm-text-muted, #666);font-size:.9rem}.dmc-panel{display:grid;grid-template-columns:minmax(0,3fr) minmax(0,2fr);gap:1.5rem;align-items:start}.dmc-panel--msg{display:block;text-align:center;padding:3rem 1rem}.dmc-preview{position:relative;aspect-ratio:16 / 9;background:#111;border-radius:.75rem;overflow:hidden}.dmc-preview video,.dmc-tile video{width:100%;height:100%;object-fit:cover;display:block}.dmc-self,.dmc-self-preview{transform:scaleX(-1)}.dmc-nocam{position:absolute;inset:0;display:grid;place-items:center;color:#ddd;margin:0}.dmc-check h2{margin-top:0}.dmc-label{display:grid;gap:.35rem;margin:1rem 0;font-weight:600}.dmc-input{font:inherit;padding:.55rem .7rem;border:1px solid var(--dm-border, #ccc);border-radius:.5rem;background:var(--dm-surface, #fff);color:inherit;min-width:0}.dmc-row{display:flex;gap:.5rem;flex-wrap:wrap;margin:1rem 0}.dmc-note{color:var(--dm-text-muted, #666)}.dmc-error{color:var(--dm-danger, #c62828);font-weight:600}.dmc-btn{font:inherit;cursor:pointer;padding:.55rem 1rem;border-radius:.5rem;border:1px solid var(--dm-border, #ccc);background:var(--dm-surface, #fff);color:inherit}.dmc-btn:hover{border-color:var(--dm-primary, #555)}.dmc-btn:disabled{opacity:.6;cursor:default}.dmc-btn.is-off{background:var(--dm-danger, #c62828);border-color:transparent;color:#fff}.dmc-btn--go{background:var(--dm-primary, #1f6feb);border-color:transparent;color:#fff}.dmc-btn--leave{background:var(--dm-danger, #c62828);border-color:transparent;color:#fff}.dmc-btn--rec{border-color:var(--dm-danger, #c62828)}.dmc-btn--small{padding:.3rem .65rem;font-size:.9rem}.dmc-call{display:grid;grid-template-columns:minmax(0,1fr) auto;grid-template-rows:1fr auto;gap:var(--dmc-gap)}.dmc-main{display:grid;gap:var(--dmc-gap);grid-template-columns:repeat(auto-fit,minmax(min(100%,280px),1fr));align-content:start}.dmc-main[data-people="1"]{grid-template-columns:minmax(0,1fr)}.dmc-main[data-people="2"]{grid-template-columns:repeat(auto-fit,minmax(min(100%,360px),1fr))}.dmc-grid,.dmc-remote{display:contents}.dmc-tile{position:relative;margin:0;aspect-ratio:16 / 9;background:#111;border-radius:.75rem;overflow:hidden}.dmc-tile figcaption{position:absolute;left:.5rem;bottom:.5rem;padding:.15rem .5rem;border-radius:.35rem;background:#0009;color:#fff;font-size:.85rem}.dmc-side{width:300px;display:flex;flex-direction:column;gap:1rem;grid-row:1 / span 1;grid-column:2}.dmc-side h3{margin:0 0 .5rem;font-size:1rem}.dmc-waiting ul{list-style:none;margin:0;padding:0;display:grid;gap:.5rem}.dmc-waiting li{display:flex;align-items:center;gap:.4rem;flex-wrap:wrap}.dmc-waiting li span{flex:1 1 100%;font-weight:600}.dmc-chat{display:flex;flex-direction:column;min-height:0;flex:1}.dmc-messages{list-style:none;margin:0 0 .5rem;padding:0;overflow-y:auto;max-height:50vh;display:grid;gap:.4rem}.dmc-messages li.is-mine strong{color:var(--dm-primary, #1f6feb)}.dmc-send{display:flex;gap:.4rem}.dmc-send .dmc-input{flex:1}.dmc-bar{grid-column:1 / -1;display:flex;gap:.5rem;flex-wrap:wrap;justify-content:center}@media(max-width:760px){.dmc-panel,.dmc-call{grid-template-columns:1fr}.dmc-side{width:auto;grid-column:1;grid-row:auto}.dmc-bar{position:sticky;bottom:0;background:var(--dm-background, #fff);padding:.5rem 0}.dmc-bar .dmc-btn{flex:1 1 30%}}