meno-core 1.0.49 → 1.0.50

package/lib/server/providers/fileSystemCMSProvider.ts

@@ -30,12 +30,16 @@ async function loadJSONFile(filePath: string): Promise<unknown | null> {
 }
 
 /**
- * Normalize a raw CMS item by adding _slug and _filename fields.
+ * Normalize a raw CMS item by adding _slug, _filename, and _id (backfilled
+ * from filename for items written without one — the editor stopped writing
+ * a separate random _id once _filename became the canonical identifier).
  * If `isDraft` is true, also sets the transient `_isDraft` flag.
  */
 function normalizeItem(content: unknown, filename: string, isDraft = false): CMSItem {
+  const raw = content as CMSItem;
   const base: CMSItem = {
-    ...content as CMSItem,
+    ...raw,
+    _id: raw._id || filename,
     _slug: filename,
     _filename: filename,
   };
@@ -45,10 +49,18 @@ function normalizeItem(content: unknown, filename: string, isDraft = false): CMS
 
 /**
  * Strip transient fields that must never be persisted to disk.
+ * Also drops `_filename` when it equals `_id` (the canonical case for new
+ * items) so the field stops accumulating in storage. Legacy items where
+ * `_filename` differs from `_id` keep the field on disk so the on-disk
+ * file-routing path can still find them.
  */
 function stripTransient<T extends Record<string, unknown>>(item: T): Omit<T, '_slug' | '_isDraft' | '_hasDraft' | '_url'> {
-  const { _slug, _isDraft, _hasDraft, _url, ...rest } = item;
-  return rest;
+  const { _slug, _isDraft, _hasDraft, _url, _filename, ...rest } = item;
+  const out = rest as Omit<T, '_slug' | '_isDraft' | '_hasDraft' | '_url'>;
+  if (typeof _filename === 'string' && _filename !== (out as Record<string, unknown>)._id) {
+    (out as Record<string, unknown>)._filename = _filename;
+  }
+  return out;
 }
 
 /**
@@ -217,8 +229,10 @@ export class FileSystemCMSProvider implements CMSProvider {
   }
 
   /**
-   * Save item to file system
-   * Uses _filename for file path (stable, doesn't change when slug changes)
+   * Save item to file system.
+   * The on-disk filename is derived from `_filename` (legacy alias) when set,
+   * otherwise from `_id` (canonical identifier; equals the filename for new
+   * items). Falls back to the slugField value as a last resort.
    */
   async saveItem(collection: string, item: CMSItem): Promise<void> {
     this.validateCollection(collection);
@@ -232,21 +246,31 @@ export class FileSystemCMSProvider implements CMSProvider {
       throw new Error(`Unknown collection: ${collection}`);
     }
 
-    // Use _filename for file path (new behavior)
-    // Falls back to slugField for backward compatibility with items without _filename
+    // Filename derivation precedence:
+    // 1. `_filename` — explicit on-disk filename. Used by the editor (preserves
+    //    legacy items where `_filename` differs from `_id`).
+    // 2. slug-field value — back-compat for external API callers who build
+    //    items from raw input with a slug field.
+    // 3. `_id` — last resort. For new items written by the editor `_id`
+    //    equals the filename, so this path also produces the correct name.
     let filename: string;
 
     if (item._filename) {
       filename = item._filename;
     } else {
-      // Legacy fallback: use slug field value (may break for i18n slugs)
       const slugField = schemaInfo.schema.slugField;
       const slugValue = item[slugField];
-      filename = typeof slugValue === 'string' ? slugValue : String(slugValue);
+      if (typeof slugValue === 'string' && slugValue) {
+        filename = slugValue;
+      } else if (typeof item._id === 'string' && item._id) {
+        filename = item._id;
+      } else {
+        filename = String(slugValue);
+      }
     }
 
     if (!filename || filename === '[object Object]') {
-      throw new Error('Missing _filename field. Items must have _filename set on creation.');
+      throw new Error('Cannot derive filename: item is missing _id, _filename, and a usable slug-field value.');
     }
 
     // Validate filename to prevent path traversal
@@ -345,7 +369,8 @@ export class FileSystemCMSProvider implements CMSProvider {
   /**
    * Save the draft version of an item. Loose validation — drafts may have
    * missing required fields or partial data. Strict validation only runs at
-   * publish time. The item's `_filename` determines the target file.
+   * publish time. The on-disk filename is derived the same way as for
+   * `saveItem` (prefer `_filename`, fall back to `_id`).
    */
   async saveDraft(collection: string, item: CMSItem): Promise<void> {
     this.validateCollection(collection);
@@ -357,17 +382,24 @@ export class FileSystemCMSProvider implements CMSProvider {
       throw new Error(`Unknown collection: ${collection}`);
     }
 
+    // Filename derivation: same precedence as saveItem.
     let filename: string;
     if (item._filename) {
       filename = item._filename;
     } else {
       const slugField = schemaInfo.schema.slugField;
       const slugValue = item[slugField];
-      filename = typeof slugValue === 'string' ? slugValue : String(slugValue);
+      if (typeof slugValue === 'string' && slugValue) {
+        filename = slugValue;
+      } else if (typeof item._id === 'string' && item._id) {
+        filename = item._id;
+      } else {
+        filename = String(slugValue);
+      }
     }
 
     if (!filename || filename === '[object Object]') {
-      throw new Error('Missing _filename field. Drafts must have _filename set on creation.');
+      throw new Error('Cannot derive draft filename: item is missing _id, _filename, and a usable slug-field value.');
     }
 
     this.validateFilename(filename);

package/lib/server/services/configService.ts

@@ -25,6 +25,7 @@ import { readTextFile, fileExists } from '../runtime';
  */
 export interface IconsConfig {
   favicon?: string;
+  faviconDark?: string;
   appleTouchIcon?: string;
 }
 

package/lib/server/services/fileWatcherService.ts

@@ -14,6 +14,7 @@ import { PageCache } from '../pageCache';
 import { colorService } from './ColorService';
 import { variableService } from './VariableService';
 import { enumService } from './EnumService';
+import { configService } from './configService';
 import { loadJSONFile, mapPageNameToPath } from '../jsonLoader';
 import { buildLineMap } from '../utils/jsonLineMapper';
 import { projectPaths } from '../projectContext';
@@ -71,9 +72,14 @@ export class FileWatcherService {
             clearTimeout(this.refreshSchemasTimer);
           }
           const cmsService = this.cmsService;
+          const wsManager = this.wsManager;
           this.refreshSchemasTimer = setTimeout(async () => {
             this.refreshSchemasTimer = null;
             await cmsService.refreshSchemas();
+            // Tell connected studio clients to re-fetch the collections list.
+            // Without this, the CMS panel only refreshes after a dev-server
+            // restart even though the server cache is now correct.
+            wsManager.broadcastCollectionsUpdate();
           }, 50);
         }
       },
@@ -96,6 +102,9 @@ export class FileWatcherService {
         this.wsManager.broadcastEnumsUpdate();
       },
       onCMSChange: async (collection: string) => {
+        // Drop the items cache for this collection so the next read returns
+        // fresh data immediately, not the previous TTL-cached snapshot.
+        this.cmsService?.clearItemsCache(collection);
         // Broadcast to all clients to refresh CMS content
         this.wsManager.broadcastCMSUpdate(collection);
       },
@@ -103,6 +112,14 @@ export class FileWatcherService {
       onLibraryChange: async () => {
         this.wsManager.broadcastLibrariesUpdate();
       },
+      onProjectConfigChange: async () => {
+        // Reset the singleton config cache so the next read pulls the new
+        // i18n locales / breakpoints / icons from disk. Without this, the
+        // config API would keep serving the stale snapshot.
+        configService.reset();
+        await configService.load();
+        this.wsManager.broadcastConfigUpdate();
+      },
     });
 
     this.fileWatcher.watchAll();

package/lib/server/ssr/htmlGenerator.ts

@@ -490,14 +490,22 @@ picture {
     ? generateAllInlineDataScripts(finalClientDataCollections) + '\n  '
     : '';
 
-  // Generate favicon and apple touch icon link tags
+  // Generate favicon and apple touch icon link tags.
+  // When a dark-mode favicon is configured alongside the default, scope the
+  // default to `(prefers-color-scheme: light)` and emit a second tag scoped to
+  // `(prefers-color-scheme: dark)` so the browser swaps automatically.
+  // Note: apple-touch-icon does not honor prefers-color-scheme on iOS.
+  const hasDarkFavicon = !!(iconsConfig.favicon && iconsConfig.faviconDark);
   const faviconTag = iconsConfig.favicon
-    ? `<link rel="icon" href="${escapeHtml(iconsConfig.favicon)}" />`
+    ? `<link rel="icon" href="${escapeHtml(iconsConfig.favicon)}"${hasDarkFavicon ? ' media="(prefers-color-scheme: light)"' : ''} />`
+    : '';
+  const faviconDarkTag = iconsConfig.faviconDark
+    ? `<link rel="icon" href="${escapeHtml(iconsConfig.faviconDark)}" media="(prefers-color-scheme: dark)" />`
     : '';
   const appleTouchIconTag = iconsConfig.appleTouchIcon
     ? `<link rel="apple-touch-icon" href="${escapeHtml(iconsConfig.appleTouchIcon)}" />`
     : '';
-  const iconTags = [faviconTag, appleTouchIconTag].filter(Boolean).join('\n  ');
+  const iconTags = [faviconTag, faviconDarkTag, appleTouchIconTag].filter(Boolean).join('\n  ');
 
   // Script preload tag - eliminates critical request chain by discovering script early
   const scriptPreloadTag = extScriptPath

package/lib/server/ssr/ssrRenderer.test.ts

@@ -441,6 +441,82 @@ describe('ssrRenderer', () => {
     });
   });
 
+  // -----------------------------------------------------------------------
+  // 6b. _i18n value resolution on node children + attributes
+  // -----------------------------------------------------------------------
+  describe('buildComponentHTML - _i18n on children and attributes', () => {
+    const en = { _i18n: true, en: 'Hello', pl: 'Cześć' };
+    const i18nConfig = {
+      defaultLocale: 'en',
+      locales: [
+        { code: 'en', name: 'EN', nativeName: 'English', langTag: 'en-US' },
+        { code: 'pl', name: 'PL', nativeName: 'Polski', langTag: 'pl-PL' },
+      ],
+    };
+
+    test('resolves _i18n object as direct children for the default locale', async () => {
+      const node = { type: 'node', tag: 'h1', children: en };
+      const html = await render(node, { i18nConfig });
+      expect(html).toContain('Hello');
+      expect(html).not.toContain('Cześć');
+    });
+
+    test('resolves _i18n object as direct children for an explicit locale', async () => {
+      const node = { type: 'node', tag: 'h1', children: en };
+      const html = await render(node, { locale: 'pl', i18nConfig });
+      expect(html).toContain('Cześć');
+      expect(html).not.toContain('Hello');
+    });
+
+    test('resolves _i18n objects inside an array of children, preserving siblings', async () => {
+      const node = {
+        type: 'node',
+        tag: 'p',
+        children: [
+          en,
+          ' literal ',
+          { type: 'node', tag: 'span', children: 'static' },
+        ],
+      };
+      const html = await render(node, { i18nConfig });
+      expect(html).toContain('Hello');
+      expect(html).toContain(' literal ');
+      expect(html).toContain('<span');
+      expect(html).toContain('static');
+    });
+
+    test('resolves _i18n object on attribute values', async () => {
+      const node = {
+        type: 'node',
+        tag: 'img',
+        attributes: {
+          src: '/x.png',
+          alt: { _i18n: true, en: 'Photo', pl: 'Zdjęcie' },
+        },
+      };
+      const html = await render(node, { locale: 'pl', i18nConfig });
+      expect(html).toContain('alt="Zdjęcie"');
+    });
+
+    test('falls back to defaultLocale when the active locale key is missing', async () => {
+      const valueWithoutDe = { _i18n: true, en: 'Hello', pl: 'Cześć' };
+      const node = { type: 'node', tag: 'h1', children: valueWithoutDe };
+      const html = await render(node, { locale: 'de', i18nConfig });
+      // resolveTranslation falls back to defaultLocale (en)
+      expect(html).toContain('Hello');
+    });
+
+    test('precedence: _i18n: true wins over a stray type/tag on the same object', async () => {
+      // If someone accidentally writes both _i18n and type on the same object,
+      // i18n wins — the renderer treats it as a localized string, not a node.
+      const ambiguous = { _i18n: true, type: 'node', tag: 'div', en: 'X', pl: 'Y' };
+      const node = { type: 'node', tag: 'h1', children: ambiguous };
+      const html = await render(node, { locale: 'pl', i18nConfig });
+      expect(html).toContain('Y');
+      expect(html).not.toContain('<div');
+    });
+  });
+
   // -----------------------------------------------------------------------
   // 7. Link nodes
   // -----------------------------------------------------------------------
@@ -4060,6 +4136,188 @@ describe('ssrRenderer', () => {
     });
   });
 
+  // ---------------------------------------------------------------------------
+  // List with sourceType: 'prop' placed inside another component's slot
+  // ---------------------------------------------------------------------------
+  describe('buildComponentHTML - prop-source list inside slotted component', () => {
+    test('list with bare prop-name source resolves against host props when inside a slot', async () => {
+      // Section: a simple slot host (mirrors the user's Section component)
+      const Section: ComponentDefinition = {
+        component: {
+          interface: {
+            theme: { type: 'string', default: 'blue' },
+          },
+          structure: {
+            type: 'node',
+            tag: 'section',
+            children: [
+              { type: 'slot' },
+            ],
+          },
+        },
+      };
+
+      // Host: defines `testimonials`, renders a Section whose slot contains
+      // a list bound to the host's `testimonials` prop with a bare name.
+      const Host: ComponentDefinition = {
+        component: {
+          interface: {
+            testimonials: { type: 'list' as any, default: [] },
+          },
+          structure: {
+            type: 'node',
+            tag: 'div',
+            children: [
+              {
+                type: 'component',
+                component: 'Section',
+                props: { theme: 'blue' },
+                children: [
+                  {
+                    type: 'list',
+                    sourceType: 'prop',
+                    source: 'testimonials',
+                    children: [
+                      { type: 'node', tag: 'p', children: '{{item.name}}' },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      };
+
+      const node = {
+        type: 'component',
+        component: 'Host',
+        props: {
+          testimonials: [
+            { name: 'Alice' },
+            { name: 'Bob' },
+            { name: 'Carol' },
+          ],
+        },
+      };
+
+      const html = await render(node, { globalComponents: { Host, Section } });
+      expect(html).toContain('<section');
+      expect(html).toContain('Alice');
+      expect(html).toContain('Bob');
+      expect(html).toContain('Carol');
+    });
+
+    test('list with {{template}} source also resolves inside a slot', async () => {
+      const Section: ComponentDefinition = {
+        component: {
+          interface: {},
+          structure: {
+            type: 'node',
+            tag: 'section',
+            children: [{ type: 'slot' }],
+          },
+        },
+      };
+
+      const Host: ComponentDefinition = {
+        component: {
+          interface: {
+            testimonials: { type: 'list' as any, default: [] },
+          },
+          structure: {
+            type: 'component',
+            component: 'Section',
+            children: [
+              {
+                type: 'list',
+                sourceType: 'prop',
+                source: '{{testimonials}}',
+                children: [
+                  { type: 'node', tag: 'p', children: '{{item.name}}' },
+                ],
+              },
+            ],
+          },
+        },
+      };
+
+      const node = {
+        type: 'component',
+        component: 'Host',
+        props: { testimonials: [{ name: 'Dana' }] },
+      };
+
+      const html = await render(node, { globalComponents: { Host, Section } });
+      expect(html).toContain('Dana');
+    });
+
+    test('bare prop-name source still works when list is in component own structure (no slot)', async () => {
+      const Direct: ComponentDefinition = {
+        component: {
+          interface: {
+            items: { type: 'list' as any, default: [] },
+          },
+          structure: {
+            type: 'list',
+            sourceType: 'prop',
+            source: 'items',
+            children: [
+              { type: 'node', tag: 'li', children: '{{item.label}}' },
+            ],
+          },
+        },
+      };
+
+      const node = {
+        type: 'component',
+        component: 'Direct',
+        props: { items: [{ label: 'Eve' }, { label: 'Frank' }] },
+      };
+
+      const html = await render(node, { globalComponents: { Direct } });
+      expect(html).toContain('Eve');
+      expect(html).toContain('Frank');
+    });
+
+    test('list source stays a string and renders empty when host has no matching prop', async () => {
+      const Section: ComponentDefinition = {
+        component: {
+          interface: {},
+          structure: {
+            type: 'node',
+            tag: 'section',
+            children: [{ type: 'slot' }],
+          },
+        },
+      };
+
+      const Host: ComponentDefinition = {
+        component: {
+          interface: {},
+          structure: {
+            type: 'component',
+            component: 'Section',
+            children: [
+              {
+                type: 'list',
+                sourceType: 'prop',
+                source: 'missing',
+                children: [
+                  { type: 'node', tag: 'p', children: '{{item}}' },
+                ],
+              },
+            ],
+          },
+        },
+      };
+
+      const node = { type: 'component', component: 'Host' };
+      const html = await render(node, { globalComponents: { Host, Section } });
+      // No items - list renders empty
+      expect(html).not.toContain('<p');
+    });
+  });
+
   describe('CMS link localization', () => {
     const i18nConfig = {
       defaultLocale: 'en',

package/lib/server/ssr/ssrRenderer.ts

@@ -72,6 +72,30 @@ export interface PreloadImage {
 
 // Re-export types for external consumers
 export type { CMSContext } from './cmsSSRProcessor';
+
+/**
+ * Resolve any `_i18n` value objects inside an attributes record into the
+ * active locale's string. Authors can write `attributes: { alt: { _i18n:
+ * true, en: "Photo", pl: "Zdjęcie" } }` and the runtime substitutes a single
+ * locale-appropriate string here, before `buildAttributes` (which silently
+ * drops object-typed values to avoid `[object Object]` in HTML).
+ */
+function resolveI18nAttrs<T extends Record<string, unknown>>(
+  attrs: T,
+  locale: string | undefined,
+  i18nConfig: I18nConfig | undefined
+): T {
+  let mutated: Record<string, unknown> | null = null;
+  const config = i18nConfig ?? DEFAULT_I18N_CONFIG;
+  const effectiveLocale = locale || config.defaultLocale;
+  for (const [key, value] of Object.entries(attrs)) {
+    if (isI18nValue(value)) {
+      mutated = mutated ?? { ...attrs };
+      mutated[key] = resolveI18nValue(value, effectiveLocale, config);
+    }
+  }
+  return (mutated ?? attrs) as T;
+}
 export type { PageMeta } from './metaTagGenerator';
 export { extractPageMeta, generateMetaTags } from './metaTagGenerator';
 
@@ -968,6 +992,21 @@ async function renderNode(
 
   if (typeof node !== 'object') return '';
 
+  // Resolve `_i18n` value objects to a single string before node-shape
+  // dispatch. Authors can write a localized string anywhere `children` is
+  // accepted — on `type: "node"` elements, list templates, link children, etc.
+  // — and the runtime resolves it to the active locale here. Precedence rule:
+  // an object with both `_i18n: true` and `type`/`tag` resolves as i18n.
+  if (isI18nValue(node)) {
+    const i18nResolveConfig = i18nConfig ?? DEFAULT_I18N_CONFIG;
+    const i18nEffectiveLocale = locale || i18nResolveConfig.defaultLocale;
+    const resolved = resolveI18nValue(node, i18nEffectiveLocale, i18nResolveConfig);
+    return renderNode(
+      resolved as ComponentNode | string | number | null | undefined,
+      ctx
+    );
+  }
+
   // Check if condition - skip rendering if false
   if (!evaluateIfCondition(node as ComponentNode, ctx)) {
     return '';
@@ -1027,7 +1066,7 @@ async function renderNode(
       : sanitizedHtml;
 
     // Extract attributes from node
-    const nodeAttributes = extractAttributesFromNode(node);
+    const nodeAttributes = resolveI18nAttrs(extractAttributesFromNode(node), locale, i18nConfig);
 
     // Build className array
     const classNames: string[] = ['oem'];
@@ -1120,7 +1159,7 @@ async function renderNode(
     href = localizeHref(href, ctx);
 
     // Extract attributes from node
-    const nodeAttributes = extractAttributesFromNode(node);
+    const nodeAttributes = resolveI18nAttrs(extractAttributesFromNode(node), locale, i18nConfig);
 
     // Build className array - start with olink base class
     const classNames: string[] = ['olink'];
@@ -1201,8 +1240,10 @@ async function renderNode(
     nodeProps = processItemPropsTemplate(nodeProps, templateCtx, i18nResolver);
   }
 
-  // Extract attributes from node
-  let nodeAttributes = extractAttributesFromNode(node);
+  // Extract attributes from node. Resolve any `_i18n` value objects on
+  // attribute values to the active locale's string before downstream
+  // processing (templates, CMS substitution, kebab-casing).
+  let nodeAttributes = resolveI18nAttrs(extractAttributesFromNode(node), locale, i18nConfig);
   const originalAttributes = { ...nodeAttributes };
 
   // Process CMS templates in attributes (e.g., href="{{cms.link}}")
@@ -1826,7 +1867,7 @@ function renderLocaleList(node: import('../../shared/types').LocaleListNode, ctx
       : links.join('');
 
     // Extract attributes from node
-    const nodeAttributes = extractAttributesFromNode(node);
+    const nodeAttributes = resolveI18nAttrs(extractAttributesFromNode(node), locale, i18nConfig);
     const attrsStr = buildAttributes(nodeAttributes);
 
     const localeListResult = `<div data-locale-list="true"${containerClassAttr}${localeListStyleAttr}${attrsStr}${editorAttrs(ctx)}>${linksHTML}</div>`;

package/lib/server/webflow/buildWebflow.ts

@@ -456,7 +456,7 @@ export async function buildWebflowPayload(
           // the slug, so a template like `templates/blog.json` lands at
           // `/blog/<first-slug>` and doesn't collide with a sibling listing
           // page like `pages/blog.json`.
-          let itemSlug = item[cmsSchema.slugField] ?? item._slug ?? item._id;
+          let itemSlug = item[cmsSchema.slugField] ?? item._slug ?? item._filename ?? item._id;
           if (isI18nValue(itemSlug)) {
             itemSlug = resolveI18nValue(itemSlug, locale, i18nConfig) as string;
           }

package/lib/server/websocketManager.test.ts

@@ -1,9 +1,64 @@
-import { describe, test, expect } from 'bun:test';
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { WebSocketManager } from './websocketManager';
+import { WEBSOCKET_STATES } from '../shared/constants';
+import type { RuntimeWSClient } from './runtime';
 
-describe('websocketManager', () => {
-  test('placeholder test for coverage', () => {
-    // WebSocket tests are complex and require server setup
-    // This placeholder ensures the file appears in coverage reports
-    expect(true).toBe(true);
+function makeMockClient(readyState: number = WEBSOCKET_STATES.OPEN): RuntimeWSClient & { sent: string[] } {
+  const sent: string[] = [];
+  return {
+    readyState,
+    send(data) {
+      sent.push(typeof data === 'string' ? data : '<binary>');
+    },
+    close() {},
+    sent,
+  } as RuntimeWSClient & { sent: string[] };
+}
+
+describe('WebSocketManager', () => {
+  let manager: WebSocketManager;
+  let client: ReturnType<typeof makeMockClient>;
+
+  beforeEach(() => {
+    manager = new WebSocketManager();
+    client = makeMockClient();
+    manager.addClient(client);
+  });
+
+  describe('broadcastCollectionsUpdate', () => {
+    test('sends hmr:cms-collections-update to OPEN clients', () => {
+      manager.broadcastCollectionsUpdate();
+      expect(client.sent).toEqual([JSON.stringify({ type: 'hmr:cms-collections-update' })]);
+    });
+
+    test('skips clients that are not OPEN', () => {
+      const closing = makeMockClient(WEBSOCKET_STATES.CLOSING);
+      manager.addClient(closing);
+      manager.broadcastCollectionsUpdate();
+      expect(client.sent.length).toBe(1);
+      expect(closing.sent.length).toBe(0);
+    });
+  });
+
+  describe('broadcastCMSUpdate', () => {
+    test('includes collection in payload', () => {
+      manager.broadcastCMSUpdate('blog');
+      expect(client.sent).toEqual([JSON.stringify({ type: 'hmr:cms-update', collection: 'blog' })]);
+    });
+  });
+
+  describe('broadcastConfigUpdate', () => {
+    test('sends hmr:config-update to OPEN clients', () => {
+      manager.broadcastConfigUpdate();
+      expect(client.sent).toEqual([JSON.stringify({ type: 'hmr:config-update' })]);
+    });
+  });
+
+  describe('client lifecycle', () => {
+    test('removed clients no longer receive broadcasts', () => {
+      manager.removeClient(client);
+      manager.broadcastCollectionsUpdate();
+      expect(client.sent.length).toBe(0);
+    });
   });
 });